text stringlengths 8 4.13M |
|---|
use std::collections::HashMap;
use proconio::input;
const INF: u64 = std::u64::MAX;
// [pi, qi] ร [pj, qj] ใ t ๅบ็ปใซๅๅฒ
// min(ๅบ็ปๅ
ใฎใคใใดๅ่จ) >= m
// max(ๅบ็ปๅ
ใฎใคใใดๅ่จ) ใฎๆๅฐๅคใ่ฟใ
fn solve(
pi: usize,
pj: usize,
qi: usize,
qj: usize,
t: usize,
m: u64,
cum_sum: &CumulativeSum2D<u64>,
memo: &mut HashMap<(usize, usize, usize, usize, usize), u64>,
) -> u64 {
assert!(pi <= qi);
assert!(pj <= qj);
assert!(t >= 1);
if let Some(&ans) = memo.get(&(pi, pj, qi, qj, t)) {
return ans;
}
let s = cum_sum.sum(pi..(qi + 1), pj..(qj + 1));
let ans = if (qi - pi + 1) * (qj - pj + 1) < t {
INF
} else if s < m * t as u64 {
INF
} else if t == 1 {
assert!(s >= m);
s
} else {
let mut a = INF;
for t2 in 1..t {
for i in pi..qi {
// [pi, i], [i + 1, qi]
let l = solve(pi, pj, i, qj, t2, m, cum_sum, memo);
let r = solve(i + 1, pj, qi, qj, t - t2, m, cum_sum, memo);
a = a.min(l.max(r));
}
for j in pj..qj {
// [pj, j], [j + 1, qj]
let u = solve(pi, pj, qi, j, t2, m, cum_sum, memo);
let d = solve(pi, j + 1, qi, qj, t - t2, m, cum_sum, memo);
a = a.min(u.max(d));
}
}
a
};
memo.insert((pi, pj, qi, qj, t), ans);
// eprintln!("pi = {}, pj = {}, qi = {}, qj = {}, t = {}, m = {}, ans = {:?}", pi, pj, qi, qj, t, m, ans);
ans
}
fn main() {
input! {
h: usize,
w: usize,
t: usize,
s: [[u64; w]; h],
};
let cum_sum = CumulativeSum2D::new(&s);
let mut values = Vec::new();
for i in 0..h {
for j in 0..w {
for di in 1..=h {
for dj in 1..=w {
if i + di <= h && j + dj <= w {
values.push(cum_sum.sum(i..(i + di), j..(j + dj)));
}
}
}
}
}
values.sort();
values.dedup();
let mut ans = INF;
for min in values {
let mut memo = HashMap::new();
let v = solve(0, 0, h - 1, w - 1, t + 1, min, &cum_sum, &mut memo);
assert!(v >= min);
ans = ans.min(v - min);
}
assert_ne!(ans, INF);
println!("{}", ans);
}
use std::ops::{Add, Range, Sub};
pub struct CumulativeSum2D<T> {
h: usize,
w: usize,
cum_sum: Vec<Vec<T>>,
}
impl<T> CumulativeSum2D<T>
where
T: Clone + Copy + Default + Add<Output = T> + Sub<Output = T> + PartialOrd,
{
pub fn new(grid: &[Vec<T>]) -> Self {
let h = grid.len();
assert!(h >= 1);
let w = grid[0].len();
for row in grid {
assert_eq!(row.len(), w);
}
let mut cum_sum = grid.to_vec();
#[allow(clippy::needless_range_loop)]
for i in 0..h {
for j in 1..w {
cum_sum[i][j] = cum_sum[i][j] + cum_sum[i][j - 1];
}
}
for j in 0..w {
for i in 1..h {
cum_sum[i][j] = cum_sum[i - 1][j] + cum_sum[i][j];
}
}
Self { h, w, cum_sum }
}
pub fn sum(&self, y_range: Range<usize>, x_range: Range<usize>) -> T {
let (y_start, y_end) = (y_range.start, y_range.end);
let (x_start, x_end) = (x_range.start, x_range.end);
if y_start >= y_end || x_start >= x_end {
return T::default();
}
assert!(y_end <= self.h);
assert!(x_end <= self.w);
let sum = self.cum_sum[y_end - 1][x_end - 1];
if y_start >= 1 && x_start >= 1 {
assert!(
sum + self.cum_sum[y_start - 1][x_start - 1]
>= self.cum_sum[y_start - 1][x_end - 1] + self.cum_sum[y_end - 1][x_start - 1]
);
return sum + self.cum_sum[y_start - 1][x_start - 1]
- self.cum_sum[y_start - 1][x_end - 1]
- self.cum_sum[y_end - 1][x_start - 1];
}
if y_start >= 1 {
assert_eq!(x_start, 0);
assert!(sum >= self.cum_sum[y_start - 1][x_end - 1]);
return sum - self.cum_sum[y_start - 1][x_end - 1];
}
if x_start >= 1 {
assert_eq!(y_start, 0);
assert!(sum >= self.cum_sum[y_end - 1][x_start - 1]);
return sum - self.cum_sum[y_end - 1][x_start - 1];
}
sum
}
}
|
pub struct LinearGradientRectangle;
use crate::{
types::{HitableList, Ray, Vec3},
Camera,
{demos::Chunk, Demo},
};
impl Demo for LinearGradientRectangle {
fn name(&self) -> &'static str {
"linear-gradient-rectangle"
}
fn render_chunk(
&self,
chunk: &mut Chunk,
_camera: Option<&Camera>,
_world: Option<&HitableList>,
_samples: u8,
) {
let &mut Chunk {
x,
y,
nx,
ny,
start_x,
start_y,
ref mut buffer,
} = chunk;
// -2.0 and 4.0 in lower_left_corner and horizontal respectively
// because our canvas is in 2:1 ratio
let lower_left_corner = Vec3::new(-2.0, -1.0, -1.0);
let horizontal = Vec3::new(4.0, 0.0, 0.0);
let vertical = Vec3::new(0.0, 2.0, 0.0);
let origin = Vec3::new(0.0, 0.0, 0.0);
let mut offset = 0;
for j in start_y..start_y + ny {
for i in start_x..start_x + nx {
let u = i as f64 / x as f64;
let v = j as f64 / y as f64;
let ray = Ray::new(origin, lower_left_corner + horizontal * u + vertical * v);
let c = color(ray);
buffer[offset] = (255.99 * c.r()) as u8;
buffer[offset + 1] = (255.99 * c.g()) as u8;
buffer[offset + 2] = (255.99 * c.b()) as u8;
offset += 4;
}
}
}
}
fn color(ray: Ray) -> Vec3 {
let unit_direction = ray.direction().unit_vector();
let t = 0.5 * unit_direction.y() + 1.0;
Vec3::new(1.0, 1.0, 1.0) * (1.0 - t) + Vec3::new(0.5, 0.7, 1.0) * t
}
|
#[doc = "Reader of register SMIS"]
pub type R = crate::R<u32, super::SMIS>;
#[doc = "Reader of field `DATAMIS`"]
pub type DATAMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `STARTMIS`"]
pub type STARTMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `STOPMIS`"]
pub type STOPMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `DMARXMIS`"]
pub type DMARXMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `DMATXMIS`"]
pub type DMATXMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `TXMIS`"]
pub type TXMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `RXMIS`"]
pub type RXMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `TXFEMIS`"]
pub type TXFEMIS_R = crate::R<bool, bool>;
#[doc = "Reader of field `RXFFMIS`"]
pub type RXFFMIS_R = crate::R<bool, bool>;
impl R {
#[doc = "Bit 0 - Data Masked Interrupt Status"]
#[inline(always)]
pub fn datamis(&self) -> DATAMIS_R {
DATAMIS_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Start Condition Masked Interrupt Status"]
#[inline(always)]
pub fn startmis(&self) -> STARTMIS_R {
STARTMIS_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Stop Condition Masked Interrupt Status"]
#[inline(always)]
pub fn stopmis(&self) -> STOPMIS_R {
STOPMIS_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Receive DMA Masked Interrupt Status"]
#[inline(always)]
pub fn dmarxmis(&self) -> DMARXMIS_R {
DMARXMIS_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Transmit DMA Masked Interrupt Status"]
#[inline(always)]
pub fn dmatxmis(&self) -> DMATXMIS_R {
DMATXMIS_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Transmit FIFO Request Interrupt Mask"]
#[inline(always)]
pub fn txmis(&self) -> TXMIS_R {
TXMIS_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Receive FIFO Request Interrupt Mask"]
#[inline(always)]
pub fn rxmis(&self) -> RXMIS_R {
RXMIS_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - Transmit FIFO Empty Interrupt Mask"]
#[inline(always)]
pub fn txfemis(&self) -> TXFEMIS_R {
TXFEMIS_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - Receive FIFO Full Interrupt Mask"]
#[inline(always)]
pub fn rxffmis(&self) -> RXFFMIS_R {
RXFFMIS_R::new(((self.bits >> 8) & 0x01) != 0)
}
}
|
#![forbid(unsafe_code)]
use std::fs;
use std::io;
use std::io::{BufRead, BufReader, Read};
use std::path::PathBuf;
use anyhow::bail;
use atty::Stream;
use structopt::StructOpt;
use pop::notification::{Attachment, Notification};
#[derive(Debug, StructOpt)]
#[structopt(about, author)]
struct Opts {
/// Verbose mode
#[structopt(short, long)]
verbose: bool,
/// Pushover API token, get it on https://pushover.net/apps/build
#[structopt(short, long, env = "PUSHOVER_TOKEN")]
token: String,
/// Pushover user key, get it on https://pushover.net/
#[structopt(short, long, env = "PUSHOVER_USER")]
user: String,
/// Message to send
#[structopt(short, long)]
message: String,
/// Attachment to send, which is an image usually
#[structopt(short, long, parse(from_os_str))]
attachment: Option<PathBuf>,
/// Download and attach in request body
#[structopt(short, long)]
image_url: Option<String>,
}
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let opts: Opts = Opts::from_args();
if opts.attachment.is_some() && opts.image_url.is_some() {
bail!("either attachment or image_url is given, not both");
}
let notification = Notification::new(&opts.token, &opts.user, &opts.message);
let notification = if let Some(ref image_url) = opts.image_url {
notification.attach_url(image_url).await?
} else {
match parse_attachment(&opts)? {
Some((filename, mime_type, content)) => {
let attachment = Attachment::new(filename, mime_type, content);
notification.attach(attachment)
}
None => notification,
}
};
let response = notification.send().await?;
if opts.verbose {
println!("{}", serde_json::to_string(&response)?);
}
Ok(())
}
fn read_from_stdin_or_file(opts: &Opts) -> anyhow::Result<Option<Box<dyn BufRead>>> {
if atty::isnt(Stream::Stdin) {
// read from STDIN
Ok(Some(Box::new(BufReader::new(io::stdin()))))
} else if let Some(ref a) = opts.attachment {
// read from designated file
Ok(Some(Box::new(BufReader::new(fs::File::open(a)?))))
} else {
// Nothing
Ok(None)
}
}
fn parse_attachment(opts: &Opts) -> anyhow::Result<Option<(String, String, Vec<u8>)>> {
if let Some(mut r) = read_from_stdin_or_file(opts)? {
let mut content = Vec::new();
r.read_to_end(&mut content)?;
let mime_type = match infer::get(&content) {
Some(m) => m,
None => bail!("MIME type of attachment is unknown"),
};
let filename = match opts.attachment {
Some(ref f) => match f.to_str() {
Some(s) => s.to_string(),
None => bail!("failed to extract filename from attachment"),
},
None => format!("file.{}", mime_type.extension()),
};
let mime_type = mime_type.to_string();
Ok(Some((filename, mime_type, content)))
} else {
Ok(None)
}
}
|
// Copyright 2021 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#![allow(clippy::uninlined_format_args)]
//! This program upgrades metadata written by databend-query before 0.9 to a databend-query-0.9 compatible format.
//!
//! It loads metadata from a `raft-dir` and upgrade TableMeta to new version and write them back.
//! Both in raft-log data and in state-machine data will be converted.
//!
//! Usage:
//!
//! - Shut down all databend-meta processes.
//!
//! - Backup before proceeding: https://databend.rs/doc/deploy/metasrv/metasrv-backup-restore
//!
//! - Build it with `cargo build --bin databend-meta-upgrade-09`.
//!
//! - To view the current TableMeta version, print all TableMeta records with the following command:
//! It should display a list of TableMeta record.
//! You need to upgrade only if there is a `ver` that is lower than 24.
//!
//! ```text
//! databend-meta-upgrade-09 --cmd print --raft-dir "<./your/raft-dir/>"
//! # output:
//! # TableMeta { ver: 23, ..
//! ```
//!
//! - Run it:
//!
//! ```text
//! databend-meta-upgrade-09 --cmd upgrade --raft-dir "<./your/raft-dir/>"
//! ```
//!
//! - To assert upgrade has finished successfully, print all TableMeta records that are found in meta dir with the following command:
//! It should display a list of TableMeta record with a `ver` that is greater or equal 24.
//!
//! ```text
//! databend-meta-upgrade-09 --cmd print --raft-dir "<./your/raft-dir/>"
//! # output:
//! # TableMeta { ver: 25, ..
//! # TableMeta { ver: 25, ..
//! ```
mod rewrite;
use anyhow::Error;
use clap::Parser;
use common_meta_app::schema::TableId;
use common_meta_app::schema::TableMeta;
use common_meta_kvapi::kvapi::Key;
use common_meta_raft_store::key_spaces::RaftStoreEntry;
use common_meta_sled_store::init_sled_db;
use common_meta_types::txn_condition::Target;
use common_meta_types::txn_op::Request;
use common_meta_types::Cmd;
use common_meta_types::Entry;
use common_meta_types::LogEntry;
use common_meta_types::Operation;
use common_meta_types::SeqV;
use common_meta_types::TxnCondition;
use common_meta_types::TxnOp;
use common_meta_types::TxnPutRequest;
use common_meta_types::TxnRequest;
use common_meta_types::UpsertKV;
use common_proto_conv::FromToProto;
use common_protos::pb;
use common_tracing::init_logging;
use common_tracing::Config as LogConfig;
use openraft::EntryPayload;
use serde::Deserialize;
use serde::Serialize;
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Parser)]
#[clap(about, author)]
pub struct Config {
#[clap(long, default_value = "INFO")]
pub log_level: String,
#[clap(long, default_value = "")]
pub cmd: String,
#[clap(flatten)]
pub raft_config: RaftConfig,
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Parser)]
#[clap(about, version, author)]
#[serde(default)]
pub struct RaftConfig {
/// The dir to store persisted meta state, including raft logs, state machine etc.
#[clap(long, default_value = "./_meta")]
#[serde(alias = "kvsrv_raft_dir")]
pub raft_dir: String,
}
impl Default for RaftConfig {
fn default() -> Self {
Self {
raft_dir: "./_meta".to_string(),
}
}
}
/// Usage:
/// - To convert meta-data: `$0 --cmd upgrade --raft-dir ./_your_meta_dir/`:
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let config = Config::parse();
let _guards = init_logging("databend-meta-upgrade-09", &LogConfig::default());
eprintln!();
eprintln!("โโโโ โโโโโโโโโโโโโโโโโโโโโ โโโโโโ ");
eprintln!("โโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ");
eprintln!("โโโโโโโโโโโโโโโโโ โโโ โโโโโโโโ");
eprintln!("โโโโโโโโโโโโโโโโโ โโโ โโโโโโโโ");
eprintln!("โโโ โโโ โโโโโโโโโโโ โโโ โโโ โโโ");
eprintln!("โโโ โโโโโโโโโโโ โโโ โโโ โโโ");
eprintln!(" --- Upgrade to 0.9 --- ");
eprintln!();
eprintln!("config: {}", pretty(&config)?);
match config.cmd.as_str() {
"print" => {
print_table_meta(&config)?;
}
"upgrade" => {
let p = GenericKVProcessor {
process_pb: conv_serialized_table_meta,
};
rewrite::rewrite(&config, |x| p.process(x))?;
}
_ => {
return Err(anyhow::anyhow!("invalid cmd: {:?}", config.cmd));
}
}
Ok(())
}
/// Print TableMeta in protobuf message format that are found in log or state machine.
pub fn print_table_meta(config: &Config) -> anyhow::Result<()> {
let p = GenericKVProcessor {
process_pb: print_serialized_table_meta,
};
let raft_config = &config.raft_config;
init_sled_db(raft_config.raft_dir.clone());
for tree_iter_res in common_meta_sled_store::iter::<Vec<u8>>() {
let (_tree_name, item_iter) = tree_iter_res?;
for item_res in item_iter {
let (k, v) = item_res?;
let v1_ent = RaftStoreEntry::deserialize(&k, &v)?;
p.process(v1_ent)?;
}
}
Ok(())
}
fn conv_serialized_table_meta(key: &str, v: Vec<u8>) -> Result<Vec<u8>, anyhow::Error> {
// Only convert the key space `table-by-id`
if !key.starts_with(TableId::PREFIX) {
return Ok(v);
}
let p: pb::TableMeta = common_protos::prost::Message::decode(v.as_slice())?;
let v1: TableMeta = FromToProto::from_pb(p)?;
let p_latest = FromToProto::to_pb(&v1)?;
let mut buf = vec![];
common_protos::prost::Message::encode(&p_latest, &mut buf)?;
Ok(buf)
}
fn print_serialized_table_meta(key: &str, v: Vec<u8>) -> Result<Vec<u8>, anyhow::Error> {
if !key.starts_with(TableId::PREFIX) {
return Ok(v);
}
let p: pb::TableMeta = common_protos::prost::Message::decode(v.as_slice())?;
println!("{:?}", p);
Ok(v)
}
macro_rules! unwrap_or_return {
($v: expr) => {
if let Some(x) = $v {
x
} else {
return Ok(None);
}
};
}
trait Process {
type Inp;
type Ret;
/// It returns None if nothing has to be done.
/// Otherwise it returns Some(converted_data).
fn process(&self, input: Self::Inp) -> Result<Option<Self::Ret>, anyhow::Error>;
}
/// A processor that only processes GenericKV data.
///
/// GenericKV data will be found in state-machine, logs that operates a GenericKV or a Txn.
struct GenericKVProcessor<F>
where F: Fn(&str, Vec<u8>) -> Result<Vec<u8>, anyhow::Error>
{
/// A callback to process serialized protobuf message
process_pb: F,
}
impl<F> Process for GenericKVProcessor<F>
where F: Fn(&str, Vec<u8>) -> Result<Vec<u8>, anyhow::Error>
{
type Inp = RaftStoreEntry;
type Ret = RaftStoreEntry;
fn process(&self, input: RaftStoreEntry) -> Result<Option<RaftStoreEntry>, Error> {
self.proc_raft_store_entry(input)
}
}
impl<F> GenericKVProcessor<F>
where F: Fn(&str, Vec<u8>) -> Result<Vec<u8>, anyhow::Error>
{
/// Convert log and state machine record in meta-service.
fn proc_raft_store_entry(
&self,
input: RaftStoreEntry,
) -> Result<Option<RaftStoreEntry>, anyhow::Error> {
match input {
RaftStoreEntry::Logs { key, value } => {
let x = RaftStoreEntry::Logs {
key,
value: unwrap_or_return!(self.proc_raft_entry(value)?),
};
Ok(Some(x))
}
RaftStoreEntry::GenericKV { key, value } => {
let data = (self.process_pb)(&key, value.data)?;
let x = RaftStoreEntry::GenericKV {
key,
value: SeqV {
seq: value.seq,
meta: value.meta,
data,
},
};
Ok(Some(x))
}
RaftStoreEntry::Nodes { .. } => Ok(None),
RaftStoreEntry::StateMachineMeta { .. } => Ok(None),
RaftStoreEntry::RaftStateKV { .. } => Ok(None),
RaftStoreEntry::Expire { .. } => Ok(None),
RaftStoreEntry::Sequences { .. } => Ok(None),
RaftStoreEntry::ClientLastResps { .. } => Ok(None),
RaftStoreEntry::LogMeta { .. } => Ok(None),
}
}
fn proc_raft_entry(&self, ent: Entry) -> Result<Option<Entry>, anyhow::Error> {
match ent.payload {
EntryPayload::Blank => Ok(None),
EntryPayload::Membership(_) => Ok(None),
EntryPayload::Normal(log_entry) => {
let x = Entry {
log_id: ent.log_id,
payload: EntryPayload::Normal(unwrap_or_return!(
self.proc_log_entry(log_entry)?
)),
};
Ok(Some(x))
}
}
}
fn proc_log_entry(&self, log_entry: LogEntry) -> Result<Option<LogEntry>, anyhow::Error> {
match log_entry.cmd {
Cmd::AddNode { .. } => Ok(None),
Cmd::RemoveNode { .. } => Ok(None),
Cmd::UpsertKV(ups) => {
let x = LogEntry {
txid: log_entry.txid,
time_ms: log_entry.time_ms,
cmd: Cmd::UpsertKV(unwrap_or_return!(self.proc_upsert_kv(ups)?)),
};
Ok(Some(x))
}
Cmd::Transaction(tx) => {
let mut condition = vec![];
for c in tx.condition {
condition.push(self.proc_condition(c));
}
let mut if_then = vec![];
for op in tx.if_then {
if_then.push(self.proc_txop(op)?);
}
let mut else_then = vec![];
for op in tx.else_then {
else_then.push(self.proc_txop(op)?);
}
Ok(Some(LogEntry {
txid: log_entry.txid,
time_ms: log_entry.time_ms,
cmd: Cmd::Transaction(TxnRequest {
condition,
if_then,
else_then,
}),
}))
}
}
}
fn proc_upsert_kv(&self, ups: UpsertKV) -> Result<Option<UpsertKV>, anyhow::Error> {
match ups.value {
Operation::Update(v) => {
let buf = (self.process_pb)(&ups.key, v)?;
Ok(Some(UpsertKV {
key: ups.key,
seq: ups.seq,
value: Operation::Update(buf),
value_meta: ups.value_meta,
}))
}
Operation::Delete => Ok(None),
Operation::AsIs => Ok(None),
}
}
fn proc_condition(&self, c: TxnCondition) -> TxnCondition {
if let Some(Target::Value(_)) = &c.target {
unreachable!("we has never used value");
}
c
}
fn proc_txop(&self, op: TxnOp) -> Result<TxnOp, anyhow::Error> {
let req = match op.request {
None => {
return Ok(op);
}
Some(x) => x,
};
match req {
Request::Get(_) => {}
Request::Put(p) => {
return Ok(TxnOp {
request: Some(Request::Put(self.proc_tx_put_request(p)?)),
});
}
Request::Delete(_) => {}
Request::DeleteByPrefix(_) => {}
}
Ok(TxnOp { request: Some(req) })
}
fn proc_tx_put_request(&self, p: TxnPutRequest) -> Result<TxnPutRequest, anyhow::Error> {
let value = (self.process_pb)(&p.key, p.value)?;
let pr = TxnPutRequest {
key: p.key,
value,
prev_value: p.prev_value,
expire_at: p.expire_at,
};
Ok(pr)
}
}
fn pretty<T>(v: &T) -> Result<String, serde_json::Error>
where T: Serialize {
serde_json::to_string_pretty(v)
}
|
use blisp;
#[test]
fn test_transpile() {
let expr = "
(defun snoc (l y)
(Pure (-> (
'(t) t)
'(t)))
(match l
(nil (Cons y nil))
((Cons h b) (Cons h (snoc b y)))))
(defun rev (l)
(Pure (-> (
'(t))
'(t)))
(match l
(nil nil)
((Cons h t) (snoc (rev t) h))))
";
let exprs = blisp::init(expr, vec![]).unwrap();
let ctx = blisp::typing(exprs).unwrap();
println!("{}", blisp::transpile(&ctx));
}
|
// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
#![deny(missing_docs)]
//! Utility for sending log related messages and metrics to two different storing destinations or
//! simply to stdout/stderr. The logging destination is specified upon the initialization of the
//! logging system.
//!
//! # Enabling logging
//! There are 2 ways to enable the logging functionality:
//!
//! 1) Calling `LOGGER.preinit()`. This will enable the logger to work in limited mode.
//! In this mode the logger can only write messages to stdout or stderr.
//! The logger can be preinitialized any number of times before calling `LOGGER.init()`.
//!
//! 2) Calling `LOGGER.init()`. This will enable the logger to work in full mode.
//! In this mode the logger can write both messages and metrics to arbitrary buffers.
//! The logger can be initialized only once. Any call to the `LOGGER.init()` following that will
//! fail with an explicit error.
//!
//! ## Example for logging to stdout/stderr
//!
//! ```
//! #[macro_use]
//! extern crate logger;
//! use logger::{AppInfo, LOGGER};
//! use std::ops::Deref;
//!
//! fn main() {
//! // Optionally preinitialize the logger.
//! if let Err(e) = LOGGER.deref().preinit(Some("MY-INSTANCE".to_string())) {
//! println!("Could not preinitialize the log subsystem: {}", e);
//! return;
//! }
//! warn!("this is a warning");
//! error!("this is an error");
//! }
//! ```
//! ## Example for logging to a `File`:
//!
//! ```
//! extern crate libc;
//! extern crate utils;
//!
//! use libc::c_char;
//! use std::io::Cursor;
//!
//! #[macro_use]
//! extern crate logger;
//! use logger::{AppInfo, LOGGER};
//!
//! fn main() {
//! let mut logs = Cursor::new(vec![0; 15]);
//! let mut metrics = Cursor::new(vec![0; 15]);
//!
//! // Initialize the logger to log to a FIFO that was created beforehand.
//! assert!(LOGGER
//! .init(
//! &AppInfo::new("Firecracker", "1.0"),
//! Box::new(logs),
//! Box::new(metrics),
//! )
//! .is_ok());
//! // The following messages should appear in the in-memory buffer `logs`.
//! warn!("this is a warning");
//! error!("this is an error");
//! }
//! ```
//! # Plain log format
//! The current logging system is built upon the upstream crate 'log' and reexports the macros
//! provided by it for flushing plain log content. Log messages are printed through the use of five
//! macros:
//! * error!(<string>)
//! * warning!(<string>)
//! * info!(<string>)
//! * debug!(<string>)
//! * trace!(<string>)
//!
//! Each call to the desired macro will flush a line of the following format:
//! ```<timestamp> [<instance_id>:<level>:<file path>:<line number>] <log content>```.
//! The first component is always the timestamp which has the `%Y-%m-%dT%H:%M:%S.%f` format.
//! The level will depend on the macro used to flush a line and will be one of the following:
//! `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`.
//! The file path and the line provides the exact location of where the call to the macro was made.
//! ## Example of a log line:
//! ```bash
//! 2018-11-07T05:34:25.180751152 [anonymous-instance:ERROR:vmm/src/lib.rs:1173] Failed to log
//! metrics: Failed to write logs. Error: operation would block
//! ```
//!
//! # Metrics format
//! The metrics are flushed in JSON format each 60 seconds. The first field will always be the
//! timestamp followed by the JSON representation of the structures representing each component on
//! which we are capturing specific metrics.
//!
//! ## JSON example with metrics:
//! ```bash
//! {
//! "utc_timestamp_ms": 1541591155180,
//! "api_server": {
//! "process_startup_time_us": 0,
//! "process_startup_time_cpu_us": 0
//! },
//! "block": {
//! "activate_fails": 0,
//! "cfg_fails": 0,
//! "event_fails": 0,
//! "flush_count": 0,
//! "queue_event_count": 0,
//! "read_count": 0,
//! "write_count": 0
//! }
//! }
//! ```
//! The example above means that inside the structure representing all the metrics there is a field
//! named `block` which is in turn a serializable child structure collecting metrics for
//! the block device such as `activate_fails`, `cfg_fails`, etc.
//!
//! # Limitations
//! Metrics are only logged to buffers. Logs can be flushed either to stdout/stderr or to a
//! byte-oriented sink (File, FIFO, Ring Buffer etc).
// Workaround to `macro_reexport`.
#[macro_use]
extern crate lazy_static;
extern crate libc;
extern crate log;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
extern crate utils;
pub mod error;
pub mod metrics;
use std::io::Write;
use std::ops::Deref;
use std::result;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Mutex, MutexGuard, RwLock};
use error::LoggerError;
pub use log::Level::*;
pub use log::*;
use log::{set_logger, set_max_level, Log, Metadata, Record};
pub use metrics::{Metric, METRICS};
use utils::time::LocalTime;
/// Type for returning functions outcome.
pub type Result<T> = result::Result<T, LoggerError>;
// Values used by the Logger.
const IN_PREFIX_SEPARATOR: &str = ":";
const MSG_SEPARATOR: &str = " ";
const DEFAULT_LEVEL: Level = Level::Warn;
// Synchronization primitives used to run a one-time global initialization.
const UNINITIALIZED: usize = 0;
const PREINITIALIZING: usize = 1;
const INITIALIZING: usize = 2;
const INITIALIZED: usize = 3;
static STATE: AtomicUsize = AtomicUsize::new(0);
lazy_static! {
static ref _LOGGER_INNER: Logger = Logger::new();
}
lazy_static! {
/// Static instance used for handling human-readable logs.
///
pub static ref LOGGER: &'static Logger = {
set_logger(_LOGGER_INNER.deref()).expect("Failed to set logger");
_LOGGER_INNER.deref()
};
}
/// A structure containing info about the App that uses the logger.
pub struct AppInfo {
name: String,
version: String,
}
impl AppInfo {
/// Creates a new instance of AppInfo.
/// # Arguments
///
/// * `name` - Name of the application using this logger.
/// * `version` - Version of the application using this logger.
pub fn new(name: &str, version: &str) -> AppInfo {
AppInfo {
name: name.to_string(),
version: version.to_string(),
}
}
}
/// Logger representing the logging subsystem.
// All member fields have types which are Sync, and exhibit interior mutability, so
// we can call logging operations using a non-mut static global variable.
pub struct Logger {
show_level: AtomicBool,
show_file_path: AtomicBool,
show_line_numbers: AtomicBool,
level: AtomicUsize,
// Human readable logs will be outputted here.
log_buf: Mutex<Option<Box<dyn Write + Send>>>,
// Metrics will get flushed here.
metrics_buf: Mutex<Option<Box<dyn Write + Send>>>,
instance_id: RwLock<String>,
}
// Auxiliary function to flush a message to a entity implementing `Write` and `Send` traits.
// This is used by the internal logger to either flush human-readable logs or metrics.
fn write_to_destination(mut msg: String, buffer: &mut (dyn Write + Send)) -> Result<()> {
msg = format!("{}\n", msg);
buffer
.write(&msg.as_bytes())
.map_err(LoggerError::LogWrite)?;
buffer.flush().map_err(LoggerError::LogFlush)
}
impl Logger {
// Creates a new instance of the current logger.
//
// The default log level is `WARN` and the default destination is stdout/stderr based on level.
fn new() -> Logger {
Logger {
show_level: AtomicBool::new(true),
show_line_numbers: AtomicBool::new(true),
show_file_path: AtomicBool::new(true),
level:
// DEFAULT_LEVEL is warn so the destination output is stderr.
AtomicUsize::new(DEFAULT_LEVEL as usize),
log_buf: Mutex::new(None),
metrics_buf: Mutex::new(None),
instance_id: RwLock::new(String::new()),
}
}
fn show_level(&self) -> bool {
self.show_level.load(Ordering::Relaxed)
}
fn show_file_path(&self) -> bool {
self.show_file_path.load(Ordering::Relaxed)
}
fn show_line_numbers(&self) -> bool {
self.show_line_numbers.load(Ordering::Relaxed)
}
/// Enables or disables including the level in the log message's tag portion.
///
/// # Arguments
///
/// * `option` - Boolean deciding whether to include log level in log message.
///
/// # Example
///
/// ```
/// #[macro_use]
/// extern crate log;
/// extern crate logger;
/// use logger::LOGGER;
/// use std::ops::Deref;
///
/// fn main() {
/// let l = LOGGER.deref();
/// l.set_include_level(true);
/// assert!(l.preinit(Some("MY-INSTANCE".to_string())).is_ok());
/// warn!("A warning log message with level included");
/// }
/// ```
/// The code above will more or less print:
/// ```bash
/// 2018-11-07T05:34:25.180751152 [MY-INSTANCE:WARN:logger/src/lib.rs:290] A warning log
/// message with level included
/// ```
pub fn set_include_level(&self, option: bool) {
self.show_level.store(option, Ordering::Relaxed);
}
/// Enables or disables including the file path and the line numbers in the tag of
/// the log message. Not including the file path will also hide the line numbers from the tag.
///
/// # Arguments
///
/// * `file_path` - Boolean deciding whether to include file path of the log message's origin.
/// * `line_numbers` - Boolean deciding whether to include the line number of the file where the
/// log message orginated.
///
/// # Example
///
/// ```
/// #[macro_use]
/// extern crate logger;
/// use logger::LOGGER;
/// use std::ops::Deref;
///
/// fn main() {
/// let l = LOGGER.deref();
/// l.set_include_origin(false, false);
/// assert!(l.preinit(Some("MY-INSTANCE".to_string())).is_ok());
///
/// warn!("A warning log message with log origin disabled");
/// }
/// ```
/// The code above will more or less print:
/// ```bash
/// 2018-11-07T05:34:25.180751152 [MY-INSTANCE:WARN] A warning log message with log origin
/// disabled
/// ```
pub fn set_include_origin(&self, file_path: bool, line_numbers: bool) {
self.show_file_path.store(file_path, Ordering::Relaxed);
// If the file path is not shown, do not show line numbers either.
self.show_line_numbers
.store(file_path && line_numbers, Ordering::Relaxed);
}
/// Sets the ID for this logger session.
pub fn set_instance_id(&self, instance_id: String) {
let mut id_guard = match self.instance_id.write() {
Ok(guard) => guard,
Err(poisoned) => poisoned.into_inner(),
};
*id_guard = instance_id;
}
/// Explicitly sets the log level for the Logger.
/// The default level is WARN. So, ERROR and WARN statements will be shown (i.e. all that is
/// bigger than the level code).
///
/// # Arguments
///
/// * `level` - Set the highest log level.
/// # Example
///
/// ```
/// #[macro_use]
/// extern crate logger;
/// extern crate log;
/// use logger::LOGGER;
/// use std::ops::Deref;
///
/// fn main() {
/// let l = LOGGER.deref();
/// l.set_level(log::Level::Info);
/// assert!(l.preinit(Some("MY-INSTANCE".to_string())).is_ok());
/// info!("An informational log message");
/// }
/// ```
/// The code above will more or less print:
/// ```bash
/// 2018-11-07T05:34:25.180751152 [MY-INSTANCE:INFO:logger/src/lib.rs:389] An informational log
/// message
/// ```
pub fn set_level(&self, level: Level) {
self.level.store(level as usize, Ordering::Relaxed);
}
/// Creates the first portion (to the left of the separator)
/// of the log statement based on the logger settings.
fn create_prefix(&self, record: &Record) -> String {
let ins_id = match self.instance_id.read() {
Ok(guard) => guard.to_string(),
Err(poisoned) => poisoned.into_inner().to_string(),
};
let level = if self.show_level() {
record.level().to_string()
} else {
"".to_string()
};
let pth = if self.show_file_path() {
record.file().unwrap_or("unknown").to_string()
} else {
"".to_string()
};
let line = if self.show_line_numbers() {
if let Some(ln) = record.line() {
ln.to_string()
} else {
"".to_string()
}
} else {
"".to_string()
};
let mut prefix: Vec<String> = vec![ins_id, level, pth, line];
prefix.retain(|i| !i.is_empty());
format!(" [{}]", prefix.join(IN_PREFIX_SEPARATOR))
}
fn log_buf_guard(&self) -> MutexGuard<Option<Box<dyn Write + Send>>> {
match self.log_buf.lock() {
Ok(guard) => guard,
// If a thread panics while holding this lock, the writer within should still be usable.
// (we might get an incomplete log line or something like that).
Err(poisoned) => poisoned.into_inner(),
}
}
fn metrics_buf_guard(&self) -> MutexGuard<Option<Box<dyn Write + Send>>> {
match self.metrics_buf.lock() {
Ok(guard) => guard,
// If a thread panics while holding this lock, the writer within should still be usable.
// (we might get an incomplete log line or something like that).
Err(poisoned) => poisoned.into_inner(),
}
}
/// Try to change the state of the logger.
/// This method will succeed only if the logger is UNINITIALIZED.
fn try_lock(&self, locked_state: usize) -> Result<()> {
match STATE.compare_and_swap(UNINITIALIZED, locked_state, Ordering::SeqCst) {
PREINITIALIZING => {
// If the logger is preinitializing, an error will be returned.
METRICS.logger.log_fails.inc();
return Err(LoggerError::IsPreinitializing);
}
INITIALIZING => {
// If the logger is initializing, an error will be returned.
METRICS.logger.log_fails.inc();
return Err(LoggerError::IsInitializing);
}
INITIALIZED => {
// If the logger was already initialized, an error will be returned.
METRICS.logger.log_fails.inc();
return Err(LoggerError::AlreadyInitialized);
}
_ => {}
}
Ok(())
}
/// Preconfigure the logger prior to initialization.
/// Performs the most basic steps in order to enable the logger to write to stdout or stderr
/// even before calling LOGGER.init(). Calling this method is optional.
/// This function can be called any number of times before the initialization.
/// Any calls made after the initialization will result in `Err()`.
///
/// # Arguments
///
/// * `instance_id` - Unique string identifying this logger session.
/// This id is temporary and will be overwritten upon initialization.
///
/// # Example
///
/// ```
/// extern crate logger;
/// use logger::LOGGER;
/// use std::ops::Deref;
///
/// fn main() {
/// LOGGER
/// .deref()
/// .preinit(Some("MY-INSTANCE".to_string()))
/// .unwrap();
/// }
/// ```
pub fn preinit(&self, instance_id: Option<String>) -> Result<()> {
self.try_lock(PREINITIALIZING)?;
if let Some(some_instance_id) = instance_id {
self.set_instance_id(some_instance_id);
}
set_max_level(Level::Trace.to_level_filter());
STATE.store(UNINITIALIZED, Ordering::SeqCst);
Ok(())
}
/// Initialize log system (once and only once).
/// Every call made after the first will have no effect besides returning `Ok` or `Err`.
///
/// # Arguments
///
/// * `app_info` - Info about the app that uses the logger.
/// * `instance_id` - Unique string identifying this logger session.
/// * `log_dest` - Buffer for plain text logs. Needs to implements `Write` and `Send`.
/// * `metrics_dest` - Buffer for JSON formatted metrics. Needs to implement `Write` and `Send`.
///
/// # Example
///
/// ```
/// extern crate logger;
/// use logger::{AppInfo, LOGGER};
///
/// use std::io::Cursor;
///
/// fn main() {
/// let mut logs = Cursor::new(vec![0; 15]);
/// let mut metrics = Cursor::new(vec![0; 15]);
///
/// LOGGER.init(
/// &AppInfo::new("Firecracker", "1.0"),
/// Box::new(logs),
/// Box::new(metrics),
/// );
/// }
/// ```
pub fn init(
&self,
app_info: &AppInfo,
log_dest: Box<dyn Write + Send>,
metrics_dest: Box<dyn Write + Send>,
) -> Result<()> {
self.try_lock(INITIALIZING)?;
{
let mut g = self.log_buf_guard();
*g = Some(log_dest);
}
{
let mut g = self.metrics_buf_guard();
*g = Some(metrics_dest);
}
set_max_level(Level::Trace.to_level_filter());
STATE.store(INITIALIZED, Ordering::SeqCst);
self.log_helper(
format!("Running {} v{}", app_info.name, app_info.version),
Level::Info,
);
Ok(())
}
// In a future PR we'll update the way things are written to the selected destination to avoid
// the creation and allocation of unnecessary intermediate Strings. The log_helper method takes
// care of the common logic involved in both writing regular log messages, and dumping metrics.
fn log_helper(&self, msg: String, msg_level: Level) {
if STATE.load(Ordering::Relaxed) == INITIALIZED {
if let Some(guard) = self.log_buf_guard().as_mut() {
if write_to_destination(msg, guard).is_err() {
// No reason to log the error to stderr here, just increment the metric.
METRICS.logger.missed_log_count.inc();
}
} else {
panic!("Failed to write to the provided metrics destination due to poisoned lock");
}
} else if msg_level <= Level::Warn {
eprintln!("{}", msg);
} else {
println!("{}", msg);
}
}
/// Flushes metrics to the destination provided as argument upon initialization of the logger.
/// Upon failure, an error is returned if logger is initialized and metrics could not be flushed.
/// Upon success, the function will return `True` (if logger was initialized and metrics were
/// successfully flushed to disk) or `False` (if logger was not yet initialized).
pub fn log_metrics(&self) -> Result<bool> {
// Check that the logger is initialized.
if STATE.load(Ordering::Relaxed) == INITIALIZED {
match serde_json::to_string(METRICS.deref()) {
Ok(msg) => {
if let Some(guard) = self.metrics_buf_guard().as_mut() {
write_to_destination(msg, guard)
.map_err(|e| {
METRICS.logger.missed_metrics_count.inc();
e
})
.map(|()| true)?;
} else {
panic!("Failed to write to the provided metrics destination due to poisoned lock");
}
}
Err(e) => {
METRICS.logger.metrics_fails.inc();
return Err(LoggerError::LogMetricFailure(e.to_string()));
}
}
}
// If the logger is not initialized, no error is thrown but we do let the user know that
// metrics were not flushed.
Ok(false)
}
}
/// Implements the "Log" trait from the externally used "log" crate.
impl Log for Logger {
// Test whether the level of the log line should be outputted or not based on the currently
// configured level. If the configured level is "warning" but the line is logged through "info!"
// marco then it will not get logged.
fn enabled(&self, metadata: &Metadata) -> bool {
metadata.level() as usize <= self.level.load(Ordering::SeqCst)
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let msg = format!(
"{}{}{}{}",
LocalTime::now(),
self.create_prefix(&record),
MSG_SEPARATOR,
record.args()
);
self.log_helper(msg, record.metadata().level());
}
}
// This is currently not used.
fn flush(&self) {}
}
#[cfg(test)]
mod tests {
use std::fs::{File, OpenOptions};
use std::io::BufRead;
use std::io::BufReader;
use log::MetadataBuilder;
use super::*;
use utils::tempfile::TempFile;
const TEST_INSTANCE_ID: &str = "TEST-INSTANCE-ID";
const TEST_APP_NAME: &str = "Firecracker";
const TEST_APP_VERSION: &str = "1.0";
fn validate_logs(
log_path: &str,
expected: &[(&'static str, &'static str, &'static str, &'static str)],
) -> bool {
let f = File::open(log_path).unwrap();
let mut reader = BufReader::new(f);
let mut line = String::new();
// The first line should contain the firecracker version.
reader.read_line(&mut line).unwrap();
assert!(line.contains(TEST_APP_VERSION));
for tuple in expected {
line.clear();
// Read an actual log line.
reader.read_line(&mut line).unwrap();
assert!(line.contains(&tuple.0));
assert!(line.contains(&tuple.1));
assert!(line.contains(&tuple.2));
}
false
}
#[test]
fn test_default_values() {
let l = Logger::new();
assert_eq!(l.level.load(Ordering::Relaxed), log::Level::Warn as usize);
assert_eq!(l.show_line_numbers(), true);
assert_eq!(l.show_level(), true);
}
#[test]
#[allow(clippy::cognitive_complexity)]
fn test_init() {
let app_info = AppInfo::new(TEST_APP_NAME, TEST_APP_VERSION);
let l = LOGGER.deref();
l.set_include_origin(false, true);
assert_eq!(l.show_line_numbers(), false);
l.set_include_origin(true, true);
l.set_include_level(true);
l.set_level(log::Level::Info);
assert_eq!(l.show_line_numbers(), true);
assert_eq!(l.show_file_path(), true);
assert_eq!(l.show_level(), true);
// Trying to log metrics when logger is not initialized, should not throw error.
let res = l.log_metrics();
assert!(res.is_ok() && !res.unwrap());
l.set_instance_id(TEST_INSTANCE_ID.to_string());
// Assert that metrics cannot be flushed to stdout/stderr.
let res = l.log_metrics();
assert!(res.is_ok() && !res.unwrap());
// Assert that preinitialization works any number of times.
assert!(l.preinit(Some(TEST_INSTANCE_ID.to_string())).is_ok());
assert!(l.preinit(None).is_ok());
assert!(l.preinit(Some(TEST_INSTANCE_ID.to_string())).is_ok());
info!("info");
warn!("warning");
error!("error");
// Assert that initialization works only once.
let log_file_temp =
TempFile::new().expect("Failed to create temporary output logging file.");
let log_file = String::from(log_file_temp.as_path().to_path_buf().to_str().unwrap());
let metrics_file_temp =
TempFile::new().expect("Failed to create temporary metrics logging file.");
l.set_instance_id(TEST_INSTANCE_ID.to_string());
assert!(l
.init(
&app_info,
Box::new(
OpenOptions::new()
.read(true)
.write(true)
.open(&log_file)
.unwrap()
),
Box::new(
OpenOptions::new()
.read(true)
.write(true)
.open(metrics_file_temp.as_path())
.unwrap()
),
)
.is_ok());
info!("info");
warn!("warning");
let log_file_temp2 = TempFile::new().unwrap();
let metrics_file_temp2 = TempFile::new().unwrap();
assert!(l
.init(
&app_info,
Box::new(
OpenOptions::new()
.read(true)
.write(true)
.open(log_file_temp2.as_path())
.unwrap()
),
Box::new(
OpenOptions::new()
.read(true)
.write(true)
.open(metrics_file_temp2.as_path())
.unwrap()
),
)
.is_err());
info!("info");
warn!("warning");
error!("error");
// Here we also test that the last initialization had no effect given that the
// logging system can only be initialized with byte-oriented sinks once per program.
validate_logs(
&log_file,
&[
(TEST_INSTANCE_ID, "INFO", "lib.rs", "info"),
(TEST_INSTANCE_ID, "WARN", "lib.rs", "warn"),
(TEST_INSTANCE_ID, "INFO", "lib.rs", "info"),
(TEST_INSTANCE_ID, "WARN", "lib.rs", "warn"),
(TEST_INSTANCE_ID, "ERROR", "lib.rs", "error"),
],
);
assert!(l.log_metrics().is_ok());
STATE.store(UNINITIALIZED, Ordering::SeqCst);
l.set_include_level(true);
l.set_include_origin(false, false);
let error_metadata = MetadataBuilder::new().level(Level::Error).build();
let log_record = log::Record::builder().metadata(error_metadata).build();
Logger::log(&l, &log_record);
assert_eq!(l.show_level(), true);
assert_eq!(l.show_file_path(), false);
assert_eq!(l.show_line_numbers(), false);
l.set_include_level(false);
l.set_include_origin(true, true);
let error_metadata = MetadataBuilder::new().level(Level::Info).build();
let log_record = log::Record::builder().metadata(error_metadata).build();
Logger::log(&l, &log_record);
assert_eq!(l.show_level(), false);
assert_eq!(l.show_file_path(), true);
assert_eq!(l.show_line_numbers(), true);
}
}
|
#[macro_use]
extern crate lazy_static;
extern crate regex;
extern crate itertools;
extern crate fnv;
extern crate rustyline;
use rustyline::error::ReadlineError;
use rustyline::Editor;
#[macro_use]
#[allow(dead_code)]
mod types;
use types::{format_error};
mod reader;
mod printer;
// TODO: figure out a way to avoid including env
#[allow(dead_code)]
mod env;
fn main() {
// `()` can be used when no completer is required
let mut rl = Editor::<()>::new();
if rl.load_history(".mal-history").is_err() {
eprintln!("No previous history.");
}
loop {
let readline = rl.readline("user> ");
match readline {
Ok(line) => {
rl.add_history_entry(&line);
rl.save_history(".mal-history").unwrap();
if line.len() > 0 {
match reader::read_str(line) {
Ok(mv) => {
println!("{}", mv.pr_str(true));
},
Err(e) => println!("Error: {}", format_error(e)),
}
}
},
Err(ReadlineError::Interrupted) => continue,
Err(ReadlineError::Eof) => break,
Err(err) => {
println!("Error: {:?}", err);
break
}
}
}
}
// vim: ts=2:sw=2:expandtab
|
pub mod char_stream;
pub mod tokens;
pub mod tokeniser;
pub mod token_printer;
pub mod parser;
pub mod parser_helpers;
pub mod ast_utils;
pub mod ast_printer;
pub mod types;
mod type_printer;
|
#![no_std]
extern crate byte_tools;
extern crate block_cipher_trait;
mod sboxes_exp;
#[macro_use]
mod construct;
use byte_tools::{read_u32v_le, read_u32_le, write_u32_le};
use block_cipher_trait::{BlockCipher, NewFixKey};
use block_cipher_trait::generic_array::GenericArray;
use block_cipher_trait::generic_array::typenum::{U8, U32};
use sboxes_exp::*;
type Block = GenericArray<u8, U8>;
#[derive(Clone,Copy)]
pub struct Gost89<'a> {
sbox: &'a SBoxExp,
key: GenericArray<u32, U8>,
}
impl<'a> Gost89<'a> {
/// Create new cipher instance. Key interpreted as a 256 bit number
/// in little-endian format
pub fn new(key: &GenericArray<u8, U32>, sbox: &'a SBoxExp) -> Gost89<'a> {
let mut cipher = Gost89{sbox: sbox, key: Default::default()};
read_u32v_le(&mut cipher.key, key);
cipher
}
fn apply_sbox(&self, a: u32) -> u32 {
let mut v = 0;
for i in 0..4 {
let shft = 8*i;
let k = ((a & (0xffu32 << shft) ) >> shft) as usize;
v += (self.sbox[i][k] as u32) << shft;
}
v
}
fn g(&self, a: u32, k: u32) -> u32 {
self.apply_sbox(a.wrapping_add(k)).rotate_left(11)
}
#[inline]
fn encrypt(&self, block: &mut Block) {
let mut v = (read_u32_le(&block[0..4]), read_u32_le(&block[4..8]));
for _ in 0..3 {
for i in (0..8).rev() {
v = (v.1 ^ self.g(v.0, self.key[i]), v.0);
}
}
for i in 0..8 {
v = (v.1 ^ self.g(v.0, self.key[i]), v.0);
}
write_u32_le(&mut block[0..4], v.1);
write_u32_le(&mut block[4..8], v.0);
}
#[inline]
fn decrypt(&self, block: &mut Block) {
let mut v = (read_u32_le(&block[0..4]), read_u32_le(&block[4..8]));
for i in (0..8).rev() {
v = (v.1 ^ self.g(v.0, self.key[i]), v.0);
}
for _ in 0..3 {
for i in 0..8 {
v = (v.1 ^ self.g(v.0, self.key[i]), v.0);
}
}
write_u32_le(&mut block[0..4], v.1);
write_u32_le(&mut block[4..8], v.0);
}
}
impl<'a> BlockCipher for Gost89<'a> {
type BlockSize = U8;
#[inline]
fn encrypt_block(&self, block: &mut Block) {
self.encrypt(block);
}
#[inline]
fn decrypt_block(&self, block: &mut Block) {
self.decrypt(block);
}
}
constuct_cipher!(Magma, S_TC26);
constuct_cipher!(Gost89Test, S_TEST);
constuct_cipher!(Gost89CryptoProA, S_CRYPTOPRO_A);
constuct_cipher!(Gost89CryptoProB, S_CRYPTOPRO_B);
constuct_cipher!(Gost89CryptoProC, S_CRYPTOPRO_C);
constuct_cipher!(Gost89CryptoProD, S_CRYPTOPRO_D);
#[cfg(test)]
mod sboxes;
#[cfg(test)]
mod gen_table;
|
// Copyright (c) 2021 Quark Container Authors / 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use alloc::sync::Arc;
use spin::Mutex;
use alloc::string::ToString;
use super::super::super::super::qlib::common::*;
use super::super::super::super::qlib::linux_def::*;
use super::super::super::super::qlib::auth::*;
use super::super::super::fsutil::file::readonly_file::*;
use super::super::super::fsutil::inode::simple_file_inode::*;
use super::super::super::super::task::*;
use super::super::super::attr::*;
use super::super::super::file::*;
use super::super::super::flags::*;
use super::super::super::dirent::*;
use super::super::super::mount::*;
use super::super::super::inode::*;
use super::super::super::super::threadmgr::thread::*;
use super::super::inode::*;
pub fn NewIdMap(task: &Task, thread: &Thread, msrc: &Arc<Mutex<MountSource>>, gids: bool) -> Inode {
let v = NewIdMapSimpleFileInode(task,
thread,
&ROOT_OWNER,
&FilePermissions::FromMode(FileMode(0o400)),
FSMagic::PROC_SUPER_MAGIC,
gids);
return NewProcInode(&Arc::new(v), msrc, InodeType::SpecialFile, Some(thread.clone()))
}
pub fn NewIdMapSimpleFileInode(task: &Task,
thread: &Thread,
owner: &FileOwner,
perms: &FilePermissions,
typ: u64,
gids: bool)
-> SimpleFileInode<IdMapSimpleFileTrait> {
return SimpleFileInode::New(task, owner, perms, typ, false, IdMapSimpleFileTrait{
thread: thread.clone(),
gids: gids,
})
}
pub struct IdMapSimpleFileTrait {
pub thread: Thread,
pub gids: bool,
}
impl SimpleFileTrait for IdMapSimpleFileTrait {
fn GetFile(&self, _task: &Task, _dir: &Inode, dirent: &Dirent, flags: FileFlags) -> Result<File> {
let fops = NewIdMapReadonlyFileOperations(&self.thread, self.gids);
let file = File::New(dirent, &flags, fops);
return Ok(file);
}
}
pub fn NewIdMapReadonlyFileOperations(thread: &Thread, gids: bool)
-> ReadonlyFileOperations<IdMapReadonlyFileNode> {
return ReadonlyFileOperations {
node: IdMapReadonlyFileNode {
thread: thread.clone(),
gids: gids,
}
}
}
pub struct IdMapReadonlyFileNode {
pub thread: Thread,
pub gids: bool,
}
//todo: shall we support Write?
impl ReadonlyFileNode for IdMapReadonlyFileNode {
fn ReadAt(&self, task: &Task, _f: &File, dsts: &mut [IoVec], offset: i64, _blocking: bool) -> Result<i64> {
if offset < 0 {
return Err(Error::SysError(SysErr::EINVAL))
}
let userns = self.thread.UserNamespace();
let entries = if self.gids {
userns.GIDMap()
} else {
userns.UIDMap()
};
let mut buf = "".to_string();
for e in &entries {
buf += &format!("{} {} {}\n", e.FirstFromId, e.FirstToId, e.Len);
}
if offset as usize >= buf.len() {
return Ok(0)
}
let n = task.CopyDataOutToIovs(&buf.as_bytes()[offset as usize..], dsts)?;
return Ok(n as i64)
}
}
|
// Copyright 2020-2021, The Tremor Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use crate::errors::{Error, Result};
use crate::permge::{PriorityMerge, M};
use crate::registry::ServantId;
use crate::repository::PipelineArtefact;
use crate::url::TremorUrl;
use crate::{offramp, onramp};
use async_channel::{bounded, unbounded};
use async_std::stream::StreamExt;
use async_std::task::{self, JoinHandle};
use beef::Cow;
use std::fmt;
use std::time::Duration;
use tremor_common::ids::OperatorIdGen;
use tremor_common::time::nanotime;
use tremor_pipeline::errors::ErrorKind as PipelineErrorKind;
use tremor_pipeline::{CbAction, Event, ExecutableGraph, SignalKind};
const TICK_MS: u64 = 100;
pub(crate) type Sender = async_channel::Sender<ManagerMsg>;
type Inputs = halfbrown::HashMap<TremorUrl, (bool, Input)>;
type Dests = halfbrown::HashMap<Cow<'static, str>, Vec<(TremorUrl, Dest)>>;
type Eventset = Vec<(Cow<'static, str>, Event)>;
/// Address for a pipeline
#[derive(Clone)]
pub struct Addr {
addr: async_channel::Sender<Msg>,
cf_addr: async_channel::Sender<CfMsg>,
mgmt_addr: async_channel::Sender<MgmtMsg>,
id: ServantId,
}
impl Addr {
/// creates a new address
pub(crate) fn new(
addr: async_channel::Sender<Msg>,
cf_addr: async_channel::Sender<CfMsg>,
mgmt_addr: async_channel::Sender<MgmtMsg>,
id: ServantId,
) -> Self {
Self {
addr,
cf_addr,
mgmt_addr,
id,
}
}
#[cfg(not(tarpaulin_include))]
pub fn len(&self) -> usize {
self.addr.len()
}
#[cfg(not(tarpaulin_include))]
pub fn id(&self) -> &ServantId {
&self.id
}
pub(crate) async fn send_insight(&self, event: Event) -> Result<()> {
Ok(self.cf_addr.send(CfMsg::Insight(event)).await?)
}
pub(crate) async fn send(&self, msg: Msg) -> Result<()> {
Ok(self.addr.send(msg).await?)
}
#[cfg(not(tarpaulin_include))]
pub(crate) fn try_send(&self, msg: Msg) -> Result<()> {
Ok(self.addr.try_send(msg)?)
}
pub(crate) async fn send_mgmt(&self, msg: MgmtMsg) -> Result<()> {
Ok(self.mgmt_addr.send(msg).await?)
}
}
#[cfg(not(tarpaulin_include))]
impl fmt::Debug for Addr {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Pipeline({})", self.id)
}
}
#[derive(Debug)]
pub(crate) enum CfMsg {
Insight(Event),
}
#[derive(Debug)]
pub(crate) enum ConnectTarget {
Onramp(onramp::Addr),
Offramp(offramp::Addr),
Pipeline(Box<Addr>),
}
#[derive(Debug)]
pub(crate) enum MgmtMsg {
/// input can only ever be connected to the `in` port, so no need to include it here
ConnectInput {
input_url: TremorUrl,
target: ConnectTarget,
/// should we send insights to this input
transactional: bool,
},
ConnectOutput {
port: Cow<'static, str>,
output_url: TremorUrl,
target: ConnectTarget,
},
DisconnectOutput(Cow<'static, str>, TremorUrl),
DisconnectInput(TremorUrl),
#[cfg(test)]
Echo(async_channel::Sender<()>),
}
#[derive(Debug)]
pub(crate) enum Msg {
Event {
event: Event,
input: Cow<'static, str>,
},
Signal(Event),
}
#[derive(Debug)]
pub enum Dest {
Offramp(offramp::Addr),
Pipeline(Addr),
LinkedOnramp(onramp::Addr),
}
impl Dest {
pub async fn send_event(&mut self, input: Cow<'static, str>, event: Event) -> Result<()> {
match self {
Self::Offramp(addr) => addr.send(offramp::Msg::Event { input, event }).await?,
Self::Pipeline(addr) => addr.send(Msg::Event { input, event }).await?,
Self::LinkedOnramp(addr) => addr.send(onramp::Msg::Response(event)).await?,
}
Ok(())
}
pub async fn send_signal(&mut self, signal: Event) -> Result<()> {
match self {
Self::Offramp(addr) => addr.send(offramp::Msg::Signal(signal)).await?,
Self::Pipeline(addr) => {
// Each pipeline has their own ticks, we don't
// want to propagate them
if signal.kind != Some(SignalKind::Tick) {
addr.send(Msg::Signal(signal)).await?;
}
}
Self::LinkedOnramp(_addr) => {
// TODO implement!
//addr.send(onramp::Msg::Signal(signal)).await?
}
}
Ok(())
}
}
impl From<ConnectTarget> for Dest {
#[cfg(not(tarpaulin_include))]
fn from(ct: ConnectTarget) -> Self {
match ct {
ConnectTarget::Offramp(off) => Self::Offramp(off),
ConnectTarget::Onramp(on) => Self::LinkedOnramp(on),
ConnectTarget::Pipeline(pipe) => Self::Pipeline(*pipe),
}
}
}
/// possible pipeline event inputs, receiving insights
/// These are the same as Dest, but kept separately for clarity
#[derive(Debug)]
pub enum Input {
LinkedOfframp(offramp::Addr),
Pipeline(Addr),
Onramp(onramp::Addr),
}
impl From<ConnectTarget> for Input {
#[cfg(not(tarpaulin_include))]
fn from(ct: ConnectTarget) -> Self {
match ct {
ConnectTarget::Offramp(off) => Self::LinkedOfframp(off),
ConnectTarget::Onramp(on) => Self::Onramp(on),
ConnectTarget::Pipeline(pipe) => Self::Pipeline(*pipe),
}
}
}
pub struct Create {
pub config: PipelineArtefact,
pub id: ServantId,
}
pub(crate) enum ManagerMsg {
Stop,
Create(async_channel::Sender<Result<Addr>>, Box<Create>),
}
#[derive(Default, Debug)]
pub(crate) struct Manager {
qsize: usize,
operator_id_gen: OperatorIdGen,
}
#[inline]
async fn send_events(eventset: &mut Eventset, dests: &mut Dests) -> Result<()> {
for (output, event) in eventset.drain(..) {
if let Some(dest) = dests.get_mut(&output) {
if let Some((last, rest)) = dest.split_last_mut() {
for (id, offramp) in rest {
let port = id.instance_port_required()?.to_string().into();
offramp.send_event(port, event.clone()).await?;
}
let last_port = last.0.instance_port_required()?.to_string().into();
last.1.send_event(last_port, event).await?;
}
};
}
Ok(())
}
#[inline]
async fn send_signal(own_id: &TremorUrl, signal: Event, dests: &mut Dests) -> Result<()> {
let mut offramps = dests.values_mut().flatten();
let first = offramps.next();
for (id, offramp) in offramps {
if id != own_id {
offramp.send_signal(signal.clone()).await?;
}
}
if let Some((id, offramp)) = first {
if id != own_id {
offramp.send_signal(signal).await?;
}
}
Ok(())
}
#[inline]
async fn handle_insight(
skip_to: Option<usize>,
insight: Event,
pipeline: &mut ExecutableGraph,
inputs: &Inputs,
) {
let insight = pipeline.contraflow(skip_to, insight);
if insight.cb != CbAction::None {
let mut input_iter = inputs.iter();
let first = input_iter.next();
for (url, (send, input)) in input_iter {
let is_cb = insight.cb.is_cb();
if *send || is_cb {
if let Err(e) = match input {
Input::Onramp(addr) => addr
.send(onramp::Msg::Cb(insight.cb, insight.id.clone()))
.await
.map_err(Error::from),
Input::Pipeline(addr) => addr.send_insight(insight.clone()).await,
Input::LinkedOfframp(_addr) =>
/*
=========
IMPORTANT
=========
We do not forward Contraflow events back to linked offramps
as otherwise we might get into cycles if we dont have a cycle detector preventing this kind of setup
*/
{
Ok(())
}
} {
error!(
"[Pipeline::{}] failed to send insight to input: {} {}",
&pipeline.id, e, url
);
}
}
}
if let Some((url, (send, input))) = first {
if *send || insight.cb.is_cb() {
if let Err(e) = match input {
Input::Onramp(addr) => addr
.send(onramp::Msg::Cb(insight.cb, insight.id))
.await
.map_err(Error::from),
Input::Pipeline(addr) => addr.send_insight(insight).await,
Input::LinkedOfframp(_addr) =>
/*
=========
IMPORTANT
=========
We do not forward Contraflow events back to linked offramps
as otherwise we might get into cycles if we dont have a cycle detector preventing this kind of setup
*/
{
Ok(())
}
} {
error!(
"[Pipeline::{}] failed to send insight to input: {} {}",
&pipeline.id, e, &url
);
}
}
}
}
}
#[inline]
async fn handle_insights(pipeline: &mut ExecutableGraph, onramps: &Inputs) {
if !pipeline.insights.is_empty() {
let mut insights = Vec::with_capacity(pipeline.insights.len());
std::mem::swap(&mut insights, &mut pipeline.insights);
for (skip_to, insight) in insights.drain(..) {
handle_insight(Some(skip_to), insight, pipeline, onramps).await;
}
}
}
async fn tick(tick_tx: async_channel::Sender<Msg>) {
let mut e = Event {
ingest_ns: nanotime(),
kind: Some(SignalKind::Tick),
..Event::default()
};
while tick_tx.send(Msg::Signal(e.clone())).await.is_ok() {
task::sleep(Duration::from_millis(TICK_MS)).await;
e.ingest_ns = nanotime();
}
}
async fn handle_cf_msg(msg: CfMsg, pipeline: &mut ExecutableGraph, inputs: &Inputs) -> Result<()> {
match msg {
CfMsg::Insight(insight) => handle_insight(None, insight, pipeline, inputs).await,
}
Ok(())
}
#[cfg(not(tarpaulin_include))]
fn maybe_send(r: Result<()>) {
if let Err(e) = r {
error!("Failed to send : {}", e);
}
}
#[allow(clippy::too_many_lines)]
async fn pipeline_task(
id: TremorUrl,
mut pipeline: ExecutableGraph,
addr: Addr,
rx: async_channel::Receiver<Msg>,
cf_rx: async_channel::Receiver<CfMsg>,
mgmt_rx: async_channel::Receiver<MgmtMsg>,
) -> Result<()> {
let mut pid = id.clone();
pid.trim_to_instance();
pipeline.id = pid.to_string();
let mut dests: Dests = halfbrown::HashMap::new();
let mut inputs: Inputs = halfbrown::HashMap::new();
let mut eventset: Eventset = Vec::new();
info!("[Pipeline:{}] starting task.", id);
let ff = rx.map(M::F);
let cf = cf_rx.map(M::C);
let mf = mgmt_rx.map(M::M);
// prioritize management flow over contra flow over forward event flow
let mut s = PriorityMerge::new(mf, PriorityMerge::new(cf, ff));
while let Some(msg) = s.next().await {
match msg {
M::C(msg) => {
handle_cf_msg(msg, &mut pipeline, &inputs).await?;
}
M::F(Msg::Event { input, event }) => {
match pipeline.enqueue(&input, event, &mut eventset) {
Ok(()) => {
handle_insights(&mut pipeline, &inputs).await;
maybe_send(send_events(&mut eventset, &mut dests).await);
}
Err(e) => {
let err_str = if let PipelineErrorKind::Script(script_kind) = e.0 {
let script_error = tremor_script::errors::Error(script_kind, e.1);
// possibly a hygienic error
pipeline
.source
.as_ref()
.and_then(|s| script_error.locate_in_source(s))
.map_or_else(
|| format!(" {:?}", script_error),
|located| format!("\n{}", located),
) // add a newline to have the error nicely formatted in the log
} else {
format!(" {}", e)
};
error!("Error handling event:{}", err_str);
}
}
}
M::F(Msg::Signal(signal)) => {
if let Err(e) = pipeline.enqueue_signal(signal.clone(), &mut eventset) {
let err_str = if let PipelineErrorKind::Script(script_kind) = e.0 {
let script_error = tremor_script::errors::Error(script_kind, e.1);
// possibly a hygienic error
pipeline
.source
.as_ref()
.and_then(|s| script_error.locate_in_source(s))
.map_or_else(
|| format!(" {:?}", script_error),
|located| format!("\n{}", located),
) // add a newline to have the error nicely formatted in the log
} else {
format!(" {:?}", e)
};
error!("[Pipeline::{}] Error handling signal:{}", pid, err_str);
} else {
maybe_send(send_signal(&id, signal, &mut dests).await);
handle_insights(&mut pipeline, &inputs).await;
maybe_send(send_events(&mut eventset, &mut dests).await);
}
}
M::M(MgmtMsg::ConnectInput {
input_url,
target,
transactional,
}) => {
info!("[Pipeline::{}] Connecting {} to 'in'", pid, input_url);
inputs.insert(input_url, (transactional, target.into()));
}
M::M(MgmtMsg::ConnectOutput {
port,
output_url,
target,
}) => {
info!(
"[Pipeline::{}] Connecting '{}' to {}",
pid, &port, &output_url
);
// notify other pipeline about a new input
if let ConnectTarget::Pipeline(pipe) = &target {
// avoid linking the same pipeline as input to itself
// as this will create a nasty circle filling up queues.
// In general this does not avoid cycles via more complex constructs.
//
// Also don't connect anything as input to the metrics pipeline, as we dont want any contraflow to flow via the METRICS_PIPELINE
if !pid.same_instance_as(&output_url)
&& !crate::system::METRICS_PIPELINE.same_instance_as(&output_url)
{
if let Err(e) = pipe
.send_mgmt(MgmtMsg::ConnectInput {
input_url: pid.clone(),
target: ConnectTarget::Pipeline(Box::new(addr.clone())),
transactional: true,
})
.await
{
error!(
"[Pipeline::{}] Error connecting input pipeline {}: {}",
pid, &output_url, e
);
}
}
}
if let Some(output_dests) = dests.get_mut(&port) {
output_dests.push((output_url, target.into()));
} else {
dests.insert(port, vec![(output_url, target.into())]);
}
}
M::M(MgmtMsg::DisconnectOutput(port, to_delete)) => {
info!(
"[Pipeline::{}] Disconnecting {} from '{}'",
pid, &to_delete, &port
);
let mut remove = false;
if let Some(output_vec) = dests.get_mut(&port) {
while let Some(index) = output_vec.iter().position(|(k, _)| k == &to_delete) {
if let (delete_url, Dest::Pipeline(pipe)) = output_vec.swap_remove(index) {
if let Err(e) =
pipe.send_mgmt(MgmtMsg::DisconnectInput(id.clone())).await
{
error!(
"[Pipeline::{}] Error disconnecting input pipeline {}: {}",
pid, &delete_url, e
);
}
}
}
remove = output_vec.is_empty();
}
if remove {
dests.remove(&port);
}
}
M::M(MgmtMsg::DisconnectInput(input_url)) => {
info!("[Pipeline::{}] Disconnecting {} from 'in'", pid, &input_url);
inputs.remove(&input_url);
}
#[cfg(test)]
M::M(MgmtMsg::Echo(sender)) => {
if let Err(e) = sender.send(()).await {
error!(
"[Pipeline::{}] Error responding to echo message: {}",
pid, e
);
}
}
}
}
info!("[Pipeline:{}] stopping task.", id);
Ok(())
}
impl Manager {
pub fn new(qsize: usize) -> Self {
Self {
qsize,
operator_id_gen: OperatorIdGen::new(),
}
}
pub fn start(mut self) -> (JoinHandle<Result<()>>, Sender) {
let (tx, rx) = bounded(crate::QSIZE);
let h = task::spawn(async move {
info!("Pipeline manager started");
loop {
match rx.recv().await {
Ok(ManagerMsg::Stop) => {
info!("Stopping onramps...");
break;
}
Ok(ManagerMsg::Create(r, create)) => {
r.send(self.start_pipeline(*create)).await?;
}
Err(e) => {
info!("Stopping Pipeline manager... {}", e);
break;
}
}
}
info!("Pipeline manager stopped");
Ok(())
});
(h, tx)
}
fn start_pipeline(&mut self, req: Create) -> Result<Addr> {
let config = req.config;
let pipeline = config.to_pipe(&mut self.operator_id_gen)?;
let id = req.id.clone();
let (tx, rx) = bounded::<Msg>(self.qsize);
// We use a unbounded channel for counterflow, while an unbounded channel seems dangerous
// there is soundness to this.
// The unbounded channel ensures that on counterflow we never have to block, or in other
// words that sinks or pipelines sending data backwards always can progress passt
// the sending.
// This prevents a livelock where the sink is waiting for a full channel to send data to
// the pipeline and the pipeline is waiting for a full channel to send data to the sink.
// We prevent unbounded groth by two mechanisms:
// 1) counterflow is ALWAYS and ONLY created in response to a message
// 2) we always process counterflow prior to forward flow
//
// As long as we have counterflow messages to process, and channel size is growing we do
// not process any forward flow. Without forwardflow we stave the counterflow ensuring that
// the counterflow channel is always bounded by the forward flow in a 1:N relationship where
// N is the maximum number of counterflow events a single event can trigger.
// N is normally < 1.
let (cf_tx, cf_rx) = unbounded::<CfMsg>();
let (mgmt_tx, mgmt_rx) = bounded::<MgmtMsg>(self.qsize);
task::spawn(tick(tx.clone()));
let addr = Addr::new(tx, cf_tx, mgmt_tx, req.id);
task::Builder::new()
.name(format!("pipeline-{}", id))
.spawn(pipeline_task(
id,
pipeline,
addr.clone(),
rx,
cf_rx,
mgmt_rx,
))?;
Ok(addr)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::url::ports::OUT;
use async_std::future::timeout;
use tremor_pipeline::EventId;
use tremor_pipeline::FN_REGISTRY;
use tremor_script::prelude::*;
use tremor_script::{path::ModulePath, query::Query};
// used when we expect something
const POSITIVE_RECV_TIMEOUT: Duration = Duration::from_millis(10000);
// used when we expect nothing, to not spend too much time in this test
const NEGATIVE_RECV_TIMEOUT: Duration = Duration::from_millis(200);
async fn echo(addr: &Addr) -> Result<()> {
let (tx, rx) = async_channel::bounded(1);
addr.send_mgmt(MgmtMsg::Echo(tx)).await?;
rx.recv().await?;
Ok(())
}
/// ensure the last message has been processed by waiting for the manager to answer
/// leveraging the sequential execution at the manager task
/// this only works reliably for MgmtMsgs, not for insights or events/signals
async fn manager_fence(addr: &Addr) -> Result<()> {
echo(&addr).await
}
async fn wait_for_event(
offramp_rx: &async_channel::Receiver<offramp::Msg>,
wait_for: Option<Duration>,
) -> Result<Event> {
loop {
match timeout(wait_for.unwrap_or(POSITIVE_RECV_TIMEOUT), offramp_rx.recv()).await {
Ok(Ok(offramp::Msg::Event { event, .. })) => return Ok(event),
Ok(_) => continue, // ignore anything else, like signals
Err(_) => return Err("timeout waiting for event at offramp".into()),
}
}
}
#[async_std::test]
async fn test_pipeline_connect_disconnect() -> Result<()> {
let module_path = ModulePath { mounts: vec![] };
let query = r#"
select event
from in
into out;
"#;
let aggr_reg: tremor_script::registry::Aggr = tremor_script::aggr_registry();
let q = Query::parse(
&module_path,
"test_pipeline_connect.trickle",
query,
vec![],
&*FN_REGISTRY.lock()?,
&aggr_reg,
)?;
let config = tremor_pipeline::query::Query(q);
let id = TremorUrl::parse("/pipeline/test_pipeline_connect/instance")?;
let manager = Manager::new(12);
let (handle, sender) = manager.start();
let (tx, rx) = async_channel::bounded(1);
let create = Create { config, id };
let create_msg = ManagerMsg::Create(tx, Box::new(create));
sender.send(create_msg).await?;
let addr = rx.recv().await??;
// connect a fake onramp
let (onramp_tx, onramp_rx) = async_channel::unbounded();
let onramp_url = TremorUrl::parse("/onramp/fake_onramp/instance/out")?;
addr.send_mgmt(MgmtMsg::ConnectInput {
input_url: onramp_url.clone(),
target: ConnectTarget::Onramp(onramp_tx.clone()), // clone avoids the channel to be closed on disconnect below
transactional: true,
})
.await?;
// connect another fake onramp, not transactional
let (onramp2_tx, onramp2_rx) = async_channel::unbounded();
let onramp2_url = TremorUrl::parse("/onramp/fake_onramp2/instance/out")?;
addr.send_mgmt(MgmtMsg::ConnectInput {
input_url: onramp2_url.clone(),
target: ConnectTarget::Onramp(onramp2_tx.clone()),
transactional: false,
})
.await?;
manager_fence(&addr).await?;
// send a non-cb insight
let event_id = EventId::from((0, 0, 1));
addr.send_insight(Event {
id: event_id.clone(),
cb: CbAction::Ack,
..Event::default()
})
.await?;
// transactional onramp received it
// chose exceptionally big timeout, which we will only hit in the bad case that stuff isnt working, normally this should return fine
match timeout(POSITIVE_RECV_TIMEOUT, onramp_rx.recv()).await {
Ok(Ok(onramp::Msg::Cb(CbAction::Ack, cb_id))) => assert_eq!(cb_id, event_id),
Err(_) => assert!(false, "No msg received."),
m => assert!(false, "received unexpected msg: {:?}", m),
}
// non-transactional did not
assert!(onramp2_rx.is_empty());
// send a cb insight
let event_id = EventId::from((0, 0, 1));
addr.send_insight(Event {
id: event_id.clone(),
cb: CbAction::Close,
..Event::default()
})
.await?;
// transactional onramp received it
// chose exceptionally big timeout, which we will only hit in the bad case that stuff isnt working, normally this should return fine
match timeout(POSITIVE_RECV_TIMEOUT, onramp_rx.recv()).await {
Ok(Ok(onramp::Msg::Cb(CbAction::Close, cb_id))) => assert_eq!(cb_id, event_id),
Err(_) => assert!(false, "No msg received."),
m => assert!(false, "received unexpected msg: {:?}", m),
}
// non-transactional did also receive it
match timeout(POSITIVE_RECV_TIMEOUT, onramp2_rx.recv()).await {
Ok(Ok(onramp::Msg::Cb(CbAction::Close, cb_id))) => assert_eq!(cb_id, event_id),
Err(_) => assert!(false, "No msg received."),
m => assert!(false, "received unexpected msh: {:?}", m),
}
// disconnect our fake offramp
addr.send_mgmt(MgmtMsg::DisconnectInput(onramp_url)).await?;
manager_fence(&addr).await?; // ensure the last message has been processed
// probe it with an insight
let event_id2 = EventId::from((0, 0, 2));
addr.send_insight(Event {
id: event_id2.clone(),
cb: CbAction::Close,
..Event::default()
})
.await?;
// we expect nothing after disconnect, so we run into a timeout
match timeout(NEGATIVE_RECV_TIMEOUT, onramp_rx.recv()).await {
Ok(m) => assert!(false, "Didnt expect a message. Got: {:?}", m),
Err(_e) => {}
};
// second onramp received it, as it is a CB insight
match onramp2_rx.recv().await {
Ok(onramp::Msg::Cb(CbAction::Close, cb_id)) => assert_eq!(cb_id, event_id2),
m => assert!(false, "received unexpected msg: {:?}", m),
};
addr.send_mgmt(MgmtMsg::DisconnectInput(onramp2_url))
.await?;
manager_fence(&addr).await?; // ensure the last message has been processed
// probe it with an insight
let event_id3 = EventId::from((0, 0, 3));
addr.send_insight(Event {
id: event_id3.clone(),
cb: CbAction::Open,
..Event::default()
})
.await?;
// we expect nothing after disconnect, so we run into a timeout
match timeout(NEGATIVE_RECV_TIMEOUT, onramp2_rx.recv()).await {
Ok(m) => assert!(false, "Didnt expect a message. Got: {:?}", m),
Err(_e) => {}
};
// stopping the manager
sender.send(ManagerMsg::Stop).await?;
handle.cancel().await;
Ok(())
}
#[async_std::test]
async fn test_pipeline_event_error() -> Result<()> {
let module_path = ModulePath { mounts: vec![] };
let query = r#"
select event.non_existent
from in
into out;
"#;
let aggr_reg: tremor_script::registry::Aggr = tremor_script::aggr_registry();
let q = Query::parse(
&module_path,
"manager_error_test.trickle",
query,
vec![],
&*FN_REGISTRY.lock()?,
&aggr_reg,
)?;
let config = tremor_pipeline::query::Query(q);
let id = TremorUrl::parse("/pipeline/manager_error_test/instance")?;
let manager = Manager::new(12);
let (handle, sender) = manager.start();
let (tx, rx) = async_channel::bounded(1);
let create = Create { config, id };
let create_msg = ManagerMsg::Create(tx, Box::new(create));
sender.send(create_msg).await?;
let addr = rx.recv().await??;
let (offramp_tx, offramp_rx) = async_channel::unbounded();
let offramp_url = TremorUrl::parse("/offramp/fake_offramp/instance/in")?;
// connect a channel so we can receive events from the back of the pipeline :)
addr.send_mgmt(MgmtMsg::ConnectOutput {
port: OUT,
output_url: offramp_url.clone(),
target: ConnectTarget::Offramp(offramp_tx.clone()),
})
.await?;
manager_fence(&addr).await?;
// sending an event, that triggers an error
addr.send(Msg::Event {
event: Event::default(),
input: "in".into(),
})
.await?;
// no event at offramp
match timeout(NEGATIVE_RECV_TIMEOUT, offramp_rx.recv()).await {
Ok(Ok(m @ offramp::Msg::Event { .. })) => {
assert!(false, "Did not expect an event, but got: {:?}", m)
}
Ok(Err(e)) => return Err(e.into()),
_ => {}
};
// send a second event, that gets through
let mut second_event = Event::default();
second_event.data = literal!({
"non_existent": true
})
.into();
addr.send(Msg::Event {
event: second_event,
input: "in".into(),
})
.await?;
let event = wait_for_event(&offramp_rx, None).await?;
let (value, _meta) = event.data.suffix().clone().into_parts();
assert_eq!(Value::from(true), value); // check that we received what we sent in, not the faulty event
// disconnect the output
addr.send_mgmt(MgmtMsg::DisconnectOutput(OUT, offramp_url))
.await?;
manager_fence(&addr).await?;
// probe it with an Event
addr.send(Msg::Event {
event: Event::default(),
input: "in".into(),
})
.await?;
// we expect nothing to arrive, so we run into a timeout
match timeout(NEGATIVE_RECV_TIMEOUT, offramp_rx.recv()).await {
Ok(Ok(m @ offramp::Msg::Event { .. })) => {
assert!(false, "Didnt expect to receive something, got: {:?}", m)
}
Ok(Err(e)) => return Err(e.into()),
_ => {}
};
// stopping the manager
sender.send(ManagerMsg::Stop).await?;
handle.cancel().await;
Ok(())
}
}
|
//! Proof checker for Varisat proofs.
use std::io;
use anyhow::Error;
use partial_ref::{IntoPartialRefMut, PartialRef};
use thiserror::Error;
use varisat_dimacs::DimacsParser;
use varisat_formula::{CnfFormula, Lit};
pub mod internal;
mod clauses;
mod context;
mod hash;
mod processing;
mod rup;
mod sorted_lits;
mod state;
mod tmp;
mod transcript;
mod variables;
pub use processing::{
CheckedProofStep, CheckedSamplingMode, CheckedUserVar, CheckerData, ProofProcessor,
ResolutionPropagations,
};
pub use transcript::{ProofTranscriptProcessor, ProofTranscriptStep};
use clauses::add_clause;
use context::Context;
use state::check_proof;
/// Possible errors while checking a varisat proof.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum CheckerError {
#[error("step {}: Unexpected end of proof file", step)]
ProofIncomplete { step: u64 },
#[error("step {}: Error reading proof file: {}", step, cause)]
IoError {
step: u64,
#[source]
cause: io::Error,
},
#[error("step {}: Could not parse proof step: {}", step, cause)]
ParseError {
step: u64,
#[source]
cause: Error,
},
#[error("step {}: Checking proof failed: {}", step, msg)]
CheckFailed {
step: u64,
msg: String,
debug_step: String,
},
#[error("Error in proof processor: {}", cause)]
ProofProcessorError {
#[source]
cause: Error,
},
}
impl CheckerError {
/// Generate a CheckFailed error with an empty debug_step
fn check_failed(step: u64, msg: String) -> CheckerError {
CheckerError::CheckFailed {
step,
msg,
debug_step: String::new(),
}
}
}
/// A checker for unsatisfiability proofs in the native varisat format.
#[derive(Default)]
pub struct Checker<'a> {
ctx: Box<Context<'a>>,
}
impl<'a> Checker<'a> {
/// Create a new checker.
pub fn new() -> Checker<'a> {
Checker::default()
}
/// Adds a clause to the checker.
pub fn add_clause(&mut self, clause: &[Lit]) -> Result<(), CheckerError> {
let mut ctx = self.ctx.into_partial_ref_mut();
add_clause(ctx.borrow(), clause)
}
/// Add a formula to the checker.
pub fn add_formula(&mut self, formula: &CnfFormula) -> Result<(), CheckerError> {
for clause in formula.iter() {
self.add_clause(clause)?;
}
Ok(())
}
/// Reads and adds a formula in DIMACS CNF format.
///
/// Using this avoids creating a temporary [`CnfFormula`](varisat_formula::CnfFormula).
pub fn add_dimacs_cnf(&mut self, input: impl io::Read) -> Result<(), Error> {
let parser = DimacsParser::parse_incremental(input, |parser| {
Ok(self.add_formula(&parser.take_formula())?)
})?;
log::info!(
"Parsed formula with {} variables and {} clauses",
parser.var_count(),
parser.clause_count()
);
Ok(())
}
/// Add a [`ProofProcessor`].
///
/// This has to be called before loading any clauses or checking any proofs.
pub fn add_processor(&mut self, processor: &'a mut dyn ProofProcessor) {
self.ctx.processing.processors.push(processor);
}
/// Add a [`ProofTranscriptProcessor`].
///
/// This has to be called before loading any clauses or checking any proofs.
pub fn add_transcript(&mut self, processor: &'a mut dyn ProofTranscriptProcessor) {
self.ctx.processing.transcript_processors.push(processor);
}
/// Checks a proof in the native Varisat format.
pub fn check_proof(&mut self, input: impl io::Read) -> Result<(), CheckerError> {
let mut ctx = self.ctx.into_partial_ref_mut();
check_proof(ctx.borrow(), input)
}
}
#[cfg(test)]
mod tests {
use super::{internal::SelfChecker, *};
use varisat_internal_proof::{DeleteClauseProof, ProofStep};
use varisat_formula::{cnf_formula, lits, Var};
fn expect_check_failed(result: Result<(), CheckerError>, contains: &str) {
match result {
Err(CheckerError::CheckFailed { ref msg, .. }) if msg.contains(contains) => (),
err => panic!("expected {:?} error but got {:?}", contains, err),
}
}
#[test]
fn conflicting_units() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1;
-1;
])
.unwrap();
assert!(checker.ctx.checker_state.unsat);
}
#[test]
fn invalid_delete() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
-4, 5;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![-5, 4],
proof: DeleteClauseProof::Redundant,
}),
"unknown clause",
);
}
#[test]
fn ref_counts() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
1, 2, 3;
1;
])
.unwrap();
let lits = &lits![1, 2, 3][..];
checker
.self_check_step(ProofStep::DeleteClause {
clause: lits,
proof: DeleteClauseProof::Satisfied,
})
.unwrap();
checker.add_clause(lits).unwrap();
checker
.self_check_step(ProofStep::DeleteClause {
clause: lits,
proof: DeleteClauseProof::Satisfied,
})
.unwrap();
checker
.self_check_step(ProofStep::DeleteClause {
clause: lits,
proof: DeleteClauseProof::Satisfied,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: lits,
proof: DeleteClauseProof::Satisfied,
}),
"unknown clause",
);
}
#[test]
fn clause_not_found() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::AtClause {
redundant: false,
clause: [][..].into(),
propagation_hashes: [0][..].into(),
}),
"no clause found",
)
}
#[test]
fn clause_check_failed() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::AtClause {
redundant: false,
clause: [][..].into(),
propagation_hashes: [][..].into(),
}),
"AT check failed",
)
}
#[test]
fn add_derived_tautology() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::AtClause {
redundant: false,
clause: &lits![-3, 3],
propagation_hashes: &[],
}),
"tautology",
)
}
#[test]
fn delete_derived_tautology() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
-3, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![-3, 3],
proof: DeleteClauseProof::Redundant,
}),
"tautology",
)
}
#[test]
fn delete_unit_clause() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![1],
proof: DeleteClauseProof::Redundant,
}),
"delete of unit or empty clause",
)
}
#[test]
fn delete_clause_not_redundant() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![1, 2, 3],
proof: DeleteClauseProof::Redundant,
}),
"is irredundant",
)
}
#[test]
fn delete_clause_not_satisfied() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
-2;
4;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![1, 2, 3],
proof: DeleteClauseProof::Satisfied,
}),
"not satisfied",
)
}
#[test]
fn delete_clause_not_simplified() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
-3, 4;
])
.unwrap();
let hashes = [
checker.ctx.clause_hasher.clause_hash(&lits![1, 2, 3]),
checker.ctx.clause_hasher.clause_hash(&lits![-3, 4]),
];
checker
.self_check_step(ProofStep::AtClause {
redundant: false,
clause: &lits![1, 2, 4],
propagation_hashes: &hashes[..],
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteClause {
clause: &lits![1, 2, 3],
proof: DeleteClauseProof::Simplified,
}),
"not subsumed",
)
}
#[test]
fn model_unit_conflict() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1;
2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::Model {
assignment: &lits![-1, 2, -3],
}),
"conflicts with unit clause",
)
}
#[test]
fn model_internal_conflict() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
2, 3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::Model {
assignment: &lits![-1, 1, 2, -3],
}),
"conflicting assignment",
)
}
#[test]
fn model_clause_unsat() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2, 3;
-1, -2, 3;
1, -2, -3;
])
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::Model {
assignment: &lits![-1, 2, 3],
}),
"does not satisfy clause",
)
}
#[test]
fn model_conflicts_assumptions() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2;
-1, 2;
])
.unwrap();
checker
.self_check_step(ProofStep::Assumptions {
assumptions: &lits![-2],
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::Model {
assignment: &lits![1, 2],
}),
"does not contain assumption",
)
}
#[test]
fn model_misses_assumption() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2;
-1, 2;
])
.unwrap();
checker
.self_check_step(ProofStep::Assumptions {
assumptions: &lits![-3],
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::Model {
assignment: &lits![1, 2],
}),
"does not contain assumption",
)
}
#[test]
fn failed_core_with_non_assumed_vars() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2;
-1, 2;
])
.unwrap();
checker
.self_check_step(ProofStep::Assumptions {
assumptions: &lits![-2],
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::FailedAssumptions {
failed_core: &lits![-2, -3],
propagation_hashes: &[],
}),
"contains non-assumed variables",
)
}
#[test]
fn failed_assumptions_with_missing_propagations() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2;
-1, 2;
-3, -2;
])
.unwrap();
checker
.self_check_step(ProofStep::Assumptions {
assumptions: &lits![3],
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::FailedAssumptions {
failed_core: &lits![3],
propagation_hashes: &[],
}),
"AT check failed",
)
}
#[test]
fn failed_assumptions_with_conflicting_assumptions() {
let mut checker = Checker::new();
checker
.add_formula(&cnf_formula![
1, 2;
-1, 2;
-3, -2;
])
.unwrap();
checker
.self_check_step(ProofStep::Assumptions {
assumptions: &lits![3, -3, 4],
})
.unwrap();
checker
.self_check_step(ProofStep::FailedAssumptions {
failed_core: &lits![3, -3],
propagation_hashes: &[],
})
.unwrap();
}
#[test]
fn add_clause_to_non_sampling_var() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::ChangeSamplingMode {
var: Var::from_dimacs(1),
sample: false,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::AddClause {
clause: &lits![1, 2, 3],
}),
"not a sampling variable",
)
}
#[test]
fn add_clause_to_hidden_var() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::AddClause {
clause: &lits![1, 2, 3],
}),
"not a sampling variable",
)
}
#[test]
fn colloding_user_vars() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(2),
user: Some(Var::from_dimacs(1)),
}),
"used for two different variables",
)
}
#[test]
fn observe_without_setting_mode() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
}),
"still hidden",
)
}
#[test]
fn hide_hidden_var() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
}),
"no user name to remove",
)
}
#[test]
fn delete_user_var() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteVar {
var: Var::from_dimacs(1),
}),
"corresponds to user variable",
)
}
#[test]
fn delete_in_use_var() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
checker
.self_check_step(ProofStep::AddClause {
clause: &lits![1, 2, 3],
})
.unwrap();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::DeleteVar {
var: Var::from_dimacs(1),
}),
"still has clauses",
)
}
#[test]
fn invalid_hidden_to_sample() {
let mut checker = Checker::new();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: Some(Var::from_dimacs(1)),
})
.unwrap();
checker
.self_check_step(ProofStep::UserVarName {
global: Var::from_dimacs(1),
user: None,
})
.unwrap();
expect_check_failed(
checker.self_check_step(ProofStep::ChangeSamplingMode {
var: Var::from_dimacs(1),
sample: true,
}),
"cannot sample hidden variable",
)
}
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
#[cfg(feature = "Win32_System_Diagnostics_Debug_WebApp")]
pub mod WebApp;
pub const ACTIVPROF_E_PROFILER_ABSENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220991i32 as _);
pub const ACTIVPROF_E_PROFILER_PRESENT: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220992i32 as _);
pub const ACTIVPROF_E_UNABLE_TO_APPLY_ACTION: ::windows::core::HRESULT = ::windows::core::HRESULT(-2147220990i32 as _);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct ADDRESS {
pub Offset: u32,
pub Segment: u16,
pub Mode: ADDRESS_MODE,
}
#[cfg(any(target_arch = "x86",))]
impl ADDRESS {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for ADDRESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for ADDRESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ADDRESS").field("Offset", &self.Offset).field("Segment", &self.Segment).field("Mode", &self.Mode).finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for ADDRESS {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.Segment == other.Segment && self.Mode == other.Mode
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for ADDRESS {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for ADDRESS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ADDRESS64 {
pub Offset: u64,
pub Segment: u16,
pub Mode: ADDRESS_MODE,
}
impl ADDRESS64 {}
impl ::core::default::Default for ADDRESS64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ADDRESS64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ADDRESS64").field("Offset", &self.Offset).field("Segment", &self.Segment).field("Mode", &self.Mode).finish()
}
}
impl ::core::cmp::PartialEq for ADDRESS64 {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.Segment == other.Segment && self.Mode == other.Mode
}
}
impl ::core::cmp::Eq for ADDRESS64 {}
unsafe impl ::windows::core::Abi for ADDRESS64 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ADDRESS_MODE(pub i32);
pub const AddrMode1616: ADDRESS_MODE = ADDRESS_MODE(0i32);
pub const AddrMode1632: ADDRESS_MODE = ADDRESS_MODE(1i32);
pub const AddrModeReal: ADDRESS_MODE = ADDRESS_MODE(2i32);
pub const AddrModeFlat: ADDRESS_MODE = ADDRESS_MODE(3i32);
impl ::core::convert::From<i32> for ADDRESS_MODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ADDRESS_MODE {
type Abi = Self;
}
pub const ADDRESS_TYPE_INDEX_NOT_FOUND: u32 = 11u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union AER_BRIDGE_DESCRIPTOR_FLAGS {
pub Anonymous: AER_BRIDGE_DESCRIPTOR_FLAGS_0,
pub AsUSHORT: u16,
}
impl AER_BRIDGE_DESCRIPTOR_FLAGS {}
impl ::core::default::Default for AER_BRIDGE_DESCRIPTOR_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_BRIDGE_DESCRIPTOR_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_BRIDGE_DESCRIPTOR_FLAGS {}
unsafe impl ::windows::core::Abi for AER_BRIDGE_DESCRIPTOR_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct AER_BRIDGE_DESCRIPTOR_FLAGS_0 {
pub _bitfield: u16,
}
impl AER_BRIDGE_DESCRIPTOR_FLAGS_0 {}
impl ::core::default::Default for AER_BRIDGE_DESCRIPTOR_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_BRIDGE_DESCRIPTOR_FLAGS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_BRIDGE_DESCRIPTOR_FLAGS_0 {}
unsafe impl ::windows::core::Abi for AER_BRIDGE_DESCRIPTOR_FLAGS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union AER_ENDPOINT_DESCRIPTOR_FLAGS {
pub Anonymous: AER_ENDPOINT_DESCRIPTOR_FLAGS_0,
pub AsUSHORT: u16,
}
impl AER_ENDPOINT_DESCRIPTOR_FLAGS {}
impl ::core::default::Default for AER_ENDPOINT_DESCRIPTOR_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_ENDPOINT_DESCRIPTOR_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_ENDPOINT_DESCRIPTOR_FLAGS {}
unsafe impl ::windows::core::Abi for AER_ENDPOINT_DESCRIPTOR_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {
pub _bitfield: u16,
}
impl AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {}
impl ::core::default::Default for AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {}
unsafe impl ::windows::core::Abi for AER_ENDPOINT_DESCRIPTOR_FLAGS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union AER_ROOTPORT_DESCRIPTOR_FLAGS {
pub Anonymous: AER_ROOTPORT_DESCRIPTOR_FLAGS_0,
pub AsUSHORT: u16,
}
impl AER_ROOTPORT_DESCRIPTOR_FLAGS {}
impl ::core::default::Default for AER_ROOTPORT_DESCRIPTOR_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_ROOTPORT_DESCRIPTOR_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_ROOTPORT_DESCRIPTOR_FLAGS {}
unsafe impl ::windows::core::Abi for AER_ROOTPORT_DESCRIPTOR_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {
pub _bitfield: u16,
}
impl AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {}
impl ::core::default::Default for AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {}
unsafe impl ::windows::core::Abi for AER_ROOTPORT_DESCRIPTOR_FLAGS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct API_VERSION {
pub MajorVersion: u16,
pub MinorVersion: u16,
pub Revision: u16,
pub Reserved: u16,
}
impl API_VERSION {}
impl ::core::default::Default for API_VERSION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for API_VERSION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("API_VERSION").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).field("Revision", &self.Revision).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for API_VERSION {
fn eq(&self, other: &Self) -> bool {
self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion && self.Revision == other.Revision && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for API_VERSION {}
unsafe impl ::windows::core::Abi for API_VERSION {
type Abi = Self;
}
pub const API_VERSION_NUMBER: u32 = 12u32;
pub const APPBREAKFLAG_DEBUGGER_BLOCK: u32 = 1u32;
pub const APPBREAKFLAG_DEBUGGER_HALT: u32 = 2u32;
pub const APPBREAKFLAG_IN_BREAKPOINT: u32 = 2147483648u32;
pub const APPBREAKFLAG_NESTED: u32 = 131072u32;
pub const APPBREAKFLAG_STEP: u32 = 65536u32;
pub const APPBREAKFLAG_STEPTYPE_BYTECODE: u32 = 1048576u32;
pub const APPBREAKFLAG_STEPTYPE_MACHINE: u32 = 2097152u32;
pub const APPBREAKFLAG_STEPTYPE_MASK: u32 = 15728640u32;
pub const APPBREAKFLAG_STEPTYPE_SOURCE: u32 = 0u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct APPLICATION_NODE_EVENT_FILTER(pub i32);
pub const FILTER_EXCLUDE_NOTHING: APPLICATION_NODE_EVENT_FILTER = APPLICATION_NODE_EVENT_FILTER(0i32);
pub const FILTER_EXCLUDE_ANONYMOUS_CODE: APPLICATION_NODE_EVENT_FILTER = APPLICATION_NODE_EVENT_FILTER(1i32);
pub const FILTER_EXCLUDE_EVAL_CODE: APPLICATION_NODE_EVENT_FILTER = APPLICATION_NODE_EVENT_FILTER(2i32);
impl ::core::convert::From<i32> for APPLICATION_NODE_EVENT_FILTER {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for APPLICATION_NODE_EVENT_FILTER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
pub struct ARM64_NT_CONTEXT {
pub ContextFlags: u32,
pub Cpsr: u32,
pub Anonymous: ARM64_NT_CONTEXT_0,
pub Sp: u64,
pub Pc: u64,
pub V: [ARM64_NT_NEON128; 32],
pub Fpcr: u32,
pub Fpsr: u32,
pub Bcr: [u32; 8],
pub Bvr: [u64; 8],
pub Wcr: [u32; 2],
pub Wvr: [u64; 2],
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ARM64_NT_CONTEXT {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::default::Default for ARM64_NT_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for ARM64_NT_CONTEXT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::Eq for ARM64_NT_CONTEXT {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for ARM64_NT_CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
pub union ARM64_NT_CONTEXT_0 {
pub Anonymous: ARM64_NT_CONTEXT_0_0,
pub X: [u64; 31],
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ARM64_NT_CONTEXT_0 {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::default::Default for ARM64_NT_CONTEXT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for ARM64_NT_CONTEXT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::Eq for ARM64_NT_CONTEXT_0 {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for ARM64_NT_CONTEXT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
pub struct ARM64_NT_CONTEXT_0_0 {
pub X0: u64,
pub X1: u64,
pub X2: u64,
pub X3: u64,
pub X4: u64,
pub X5: u64,
pub X6: u64,
pub X7: u64,
pub X8: u64,
pub X9: u64,
pub X10: u64,
pub X11: u64,
pub X12: u64,
pub X13: u64,
pub X14: u64,
pub X15: u64,
pub X16: u64,
pub X17: u64,
pub X18: u64,
pub X19: u64,
pub X20: u64,
pub X21: u64,
pub X22: u64,
pub X23: u64,
pub X24: u64,
pub X25: u64,
pub X26: u64,
pub X27: u64,
pub X28: u64,
pub Fp: u64,
pub Lr: u64,
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ARM64_NT_CONTEXT_0_0 {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::default::Default for ARM64_NT_CONTEXT_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::fmt::Debug for ARM64_NT_CONTEXT_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct")
.field("X0", &self.X0)
.field("X1", &self.X1)
.field("X2", &self.X2)
.field("X3", &self.X3)
.field("X4", &self.X4)
.field("X5", &self.X5)
.field("X6", &self.X6)
.field("X7", &self.X7)
.field("X8", &self.X8)
.field("X9", &self.X9)
.field("X10", &self.X10)
.field("X11", &self.X11)
.field("X12", &self.X12)
.field("X13", &self.X13)
.field("X14", &self.X14)
.field("X15", &self.X15)
.field("X16", &self.X16)
.field("X17", &self.X17)
.field("X18", &self.X18)
.field("X19", &self.X19)
.field("X20", &self.X20)
.field("X21", &self.X21)
.field("X22", &self.X22)
.field("X23", &self.X23)
.field("X24", &self.X24)
.field("X25", &self.X25)
.field("X26", &self.X26)
.field("X27", &self.X27)
.field("X28", &self.X28)
.field("Fp", &self.Fp)
.field("Lr", &self.Lr)
.finish()
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for ARM64_NT_CONTEXT_0_0 {
fn eq(&self, other: &Self) -> bool {
self.X0 == other.X0
&& self.X1 == other.X1
&& self.X2 == other.X2
&& self.X3 == other.X3
&& self.X4 == other.X4
&& self.X5 == other.X5
&& self.X6 == other.X6
&& self.X7 == other.X7
&& self.X8 == other.X8
&& self.X9 == other.X9
&& self.X10 == other.X10
&& self.X11 == other.X11
&& self.X12 == other.X12
&& self.X13 == other.X13
&& self.X14 == other.X14
&& self.X15 == other.X15
&& self.X16 == other.X16
&& self.X17 == other.X17
&& self.X18 == other.X18
&& self.X19 == other.X19
&& self.X20 == other.X20
&& self.X21 == other.X21
&& self.X22 == other.X22
&& self.X23 == other.X23
&& self.X24 == other.X24
&& self.X25 == other.X25
&& self.X26 == other.X26
&& self.X27 == other.X27
&& self.X28 == other.X28
&& self.Fp == other.Fp
&& self.Lr == other.Lr
}
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
impl ::core::cmp::Eq for ARM64_NT_CONTEXT_0_0 {}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for ARM64_NT_CONTEXT_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union ARM64_NT_NEON128 {
pub Anonymous: ARM64_NT_NEON128_0,
pub D: [f64; 2],
pub S: [f32; 4],
pub H: [u16; 8],
pub B: [u8; 16],
}
impl ARM64_NT_NEON128 {}
impl ::core::default::Default for ARM64_NT_NEON128 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for ARM64_NT_NEON128 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for ARM64_NT_NEON128 {}
unsafe impl ::windows::core::Abi for ARM64_NT_NEON128 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ARM64_NT_NEON128_0 {
pub Low: u64,
pub High: i64,
}
impl ARM64_NT_NEON128_0 {}
impl ::core::default::Default for ARM64_NT_NEON128_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ARM64_NT_NEON128_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("Low", &self.Low).field("High", &self.High).finish()
}
}
impl ::core::cmp::PartialEq for ARM64_NT_NEON128_0 {
fn eq(&self, other: &Self) -> bool {
self.Low == other.Low && self.High == other.High
}
}
impl ::core::cmp::Eq for ARM64_NT_NEON128_0 {}
unsafe impl ::windows::core::Abi for ARM64_NT_NEON128_0 {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn AddVectoredContinueHandler(first: u32, handler: ::core::option::Option<PVECTORED_EXCEPTION_HANDLER>) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn AddVectoredContinueHandler(first: u32, handler: ::windows::core::RawPtr) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(AddVectoredContinueHandler(::core::mem::transmute(first), ::core::mem::transmute(handler)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn AddVectoredExceptionHandler(first: u32, handler: ::core::option::Option<PVECTORED_EXCEPTION_HANDLER>) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn AddVectoredExceptionHandler(first: u32, handler: ::windows::core::RawPtr) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(AddVectoredExceptionHandler(::core::mem::transmute(first), ::core::mem::transmute(handler)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ArrayDimension {
pub LowerBound: i64,
pub Length: u64,
pub Stride: u64,
}
impl ArrayDimension {}
impl ::core::default::Default for ArrayDimension {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ArrayDimension {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ArrayDimension").field("LowerBound", &self.LowerBound).field("Length", &self.Length).field("Stride", &self.Stride).finish()
}
}
impl ::core::cmp::PartialEq for ArrayDimension {
fn eq(&self, other: &Self) -> bool {
self.LowerBound == other.LowerBound && self.Length == other.Length && self.Stride == other.Stride
}
}
impl ::core::cmp::Eq for ArrayDimension {}
unsafe impl ::windows::core::Abi for ArrayDimension {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct AsyncIDebugApplicationNodeEvents(pub ::windows::core::IUnknown);
impl AsyncIDebugApplicationNodeEvents {
pub unsafe fn Begin_onAddChild<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpchild: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), prddpchild.into_param().abi()).ok()
}
pub unsafe fn Finish_onAddChild(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Begin_onRemoveChild<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpchild: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), prddpchild.into_param().abi()).ok()
}
pub unsafe fn Finish_onRemoveChild(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Begin_onDetach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Finish_onDetach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Begin_onAttach<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpparent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), prddpparent.into_param().abi()).ok()
}
pub unsafe fn Finish_onAttach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for AsyncIDebugApplicationNodeEvents {
type Vtable = AsyncIDebugApplicationNodeEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa2e3aa3b_aa8d_4ebf_84cd_648b737b8c13);
}
impl ::core::convert::From<AsyncIDebugApplicationNodeEvents> for ::windows::core::IUnknown {
fn from(value: AsyncIDebugApplicationNodeEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&AsyncIDebugApplicationNodeEvents> for ::windows::core::IUnknown {
fn from(value: &AsyncIDebugApplicationNodeEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for AsyncIDebugApplicationNodeEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a AsyncIDebugApplicationNodeEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct AsyncIDebugApplicationNodeEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpchild: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpchild: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpparent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
pub const BIND_ALL_IMAGES: u32 = 4u32;
pub const BIND_CACHE_IMPORT_DLLS: u32 = 8u32;
pub const BIND_NO_BOUND_IMPORTS: u32 = 1u32;
pub const BIND_NO_UPDATE: u32 = 2u32;
pub const BIND_REPORT_64BIT_VA: u32 = 16u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct BREAKPOINT_STATE(pub i32);
pub const BREAKPOINT_DELETED: BREAKPOINT_STATE = BREAKPOINT_STATE(0i32);
pub const BREAKPOINT_DISABLED: BREAKPOINT_STATE = BREAKPOINT_STATE(1i32);
pub const BREAKPOINT_ENABLED: BREAKPOINT_STATE = BREAKPOINT_STATE(2i32);
impl ::core::convert::From<i32> for BREAKPOINT_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for BREAKPOINT_STATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct BREAKREASON(pub i32);
pub const BREAKREASON_STEP: BREAKREASON = BREAKREASON(0i32);
pub const BREAKREASON_BREAKPOINT: BREAKREASON = BREAKREASON(1i32);
pub const BREAKREASON_DEBUGGER_BLOCK: BREAKREASON = BREAKREASON(2i32);
pub const BREAKREASON_HOST_INITIATED: BREAKREASON = BREAKREASON(3i32);
pub const BREAKREASON_LANGUAGE_INITIATED: BREAKREASON = BREAKREASON(4i32);
pub const BREAKREASON_DEBUGGER_HALT: BREAKREASON = BREAKREASON(5i32);
pub const BREAKREASON_ERROR: BREAKREASON = BREAKREASON(6i32);
pub const BREAKREASON_JIT: BREAKREASON = BREAKREASON(7i32);
pub const BREAKREASON_MUTATION_BREAKPOINT: BREAKREASON = BREAKREASON(8i32);
impl ::core::convert::From<i32> for BREAKREASON {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for BREAKREASON {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct BREAKRESUME_ACTION(pub i32);
pub const BREAKRESUMEACTION_ABORT: BREAKRESUME_ACTION = BREAKRESUME_ACTION(0i32);
pub const BREAKRESUMEACTION_CONTINUE: BREAKRESUME_ACTION = BREAKRESUME_ACTION(1i32);
pub const BREAKRESUMEACTION_STEP_INTO: BREAKRESUME_ACTION = BREAKRESUME_ACTION(2i32);
pub const BREAKRESUMEACTION_STEP_OVER: BREAKRESUME_ACTION = BREAKRESUME_ACTION(3i32);
pub const BREAKRESUMEACTION_STEP_OUT: BREAKRESUME_ACTION = BREAKRESUME_ACTION(4i32);
pub const BREAKRESUMEACTION_IGNORE: BREAKRESUME_ACTION = BREAKRESUME_ACTION(5i32);
pub const BREAKRESUMEACTION_STEP_DOCUMENT: BREAKRESUME_ACTION = BREAKRESUME_ACTION(6i32);
impl ::core::convert::From<i32> for BREAKRESUME_ACTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for BREAKRESUME_ACTION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct BUGCHECK_ERROR(pub u32);
pub const HARDWARE_PROFILE_UNDOCKED_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073807361u32);
pub const HARDWARE_PROFILE_DOCKED_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073807362u32);
pub const HARDWARE_PROFILE_UNKNOWN_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073807363u32);
pub const WINDOWS_NT_BANNER: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741950u32);
pub const WINDOWS_NT_CSD_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741959u32);
pub const WINDOWS_NT_INFO_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741960u32);
pub const WINDOWS_NT_MP_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741961u32);
pub const THREAD_TERMINATE_HELD_MUTEX: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741962u32);
pub const WINDOWS_NT_INFO_STRING_PLURAL: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741981u32);
pub const WINDOWS_NT_RC_STRING: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741982u32);
pub const APC_INDEX_MISMATCH: BUGCHECK_ERROR = BUGCHECK_ERROR(1u32);
pub const DEVICE_QUEUE_NOT_BUSY: BUGCHECK_ERROR = BUGCHECK_ERROR(2u32);
pub const INVALID_AFFINITY_SET: BUGCHECK_ERROR = BUGCHECK_ERROR(3u32);
pub const INVALID_DATA_ACCESS_TRAP: BUGCHECK_ERROR = BUGCHECK_ERROR(4u32);
pub const INVALID_PROCESS_ATTACH_ATTEMPT: BUGCHECK_ERROR = BUGCHECK_ERROR(5u32);
pub const INVALID_PROCESS_DETACH_ATTEMPT: BUGCHECK_ERROR = BUGCHECK_ERROR(6u32);
pub const INVALID_SOFTWARE_INTERRUPT: BUGCHECK_ERROR = BUGCHECK_ERROR(7u32);
pub const IRQL_NOT_DISPATCH_LEVEL: BUGCHECK_ERROR = BUGCHECK_ERROR(8u32);
pub const IRQL_NOT_GREATER_OR_EQUAL: BUGCHECK_ERROR = BUGCHECK_ERROR(9u32);
pub const IRQL_NOT_LESS_OR_EQUAL: BUGCHECK_ERROR = BUGCHECK_ERROR(10u32);
pub const NO_EXCEPTION_HANDLING_SUPPORT: BUGCHECK_ERROR = BUGCHECK_ERROR(11u32);
pub const MAXIMUM_WAIT_OBJECTS_EXCEEDED: BUGCHECK_ERROR = BUGCHECK_ERROR(12u32);
pub const MUTEX_LEVEL_NUMBER_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(13u32);
pub const NO_USER_MODE_CONTEXT: BUGCHECK_ERROR = BUGCHECK_ERROR(14u32);
pub const SPIN_LOCK_ALREADY_OWNED: BUGCHECK_ERROR = BUGCHECK_ERROR(15u32);
pub const SPIN_LOCK_NOT_OWNED: BUGCHECK_ERROR = BUGCHECK_ERROR(16u32);
pub const THREAD_NOT_MUTEX_OWNER: BUGCHECK_ERROR = BUGCHECK_ERROR(17u32);
pub const TRAP_CAUSE_UNKNOWN: BUGCHECK_ERROR = BUGCHECK_ERROR(18u32);
pub const EMPTY_THREAD_REAPER_LIST: BUGCHECK_ERROR = BUGCHECK_ERROR(19u32);
pub const CREATE_DELETE_LOCK_NOT_LOCKED: BUGCHECK_ERROR = BUGCHECK_ERROR(20u32);
pub const LAST_CHANCE_CALLED_FROM_KMODE: BUGCHECK_ERROR = BUGCHECK_ERROR(21u32);
pub const CID_HANDLE_CREATION: BUGCHECK_ERROR = BUGCHECK_ERROR(22u32);
pub const CID_HANDLE_DELETION: BUGCHECK_ERROR = BUGCHECK_ERROR(23u32);
pub const REFERENCE_BY_POINTER: BUGCHECK_ERROR = BUGCHECK_ERROR(24u32);
pub const BAD_POOL_HEADER: BUGCHECK_ERROR = BUGCHECK_ERROR(25u32);
pub const MEMORY_MANAGEMENT: BUGCHECK_ERROR = BUGCHECK_ERROR(26u32);
pub const PFN_SHARE_COUNT: BUGCHECK_ERROR = BUGCHECK_ERROR(27u32);
pub const PFN_REFERENCE_COUNT: BUGCHECK_ERROR = BUGCHECK_ERROR(28u32);
pub const NO_SPIN_LOCK_AVAILABLE: BUGCHECK_ERROR = BUGCHECK_ERROR(29u32);
pub const KMODE_EXCEPTION_NOT_HANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(30u32);
pub const SHARED_RESOURCE_CONV_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(31u32);
pub const KERNEL_APC_PENDING_DURING_EXIT: BUGCHECK_ERROR = BUGCHECK_ERROR(32u32);
pub const QUOTA_UNDERFLOW: BUGCHECK_ERROR = BUGCHECK_ERROR(33u32);
pub const FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(34u32);
pub const FAT_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(35u32);
pub const NTFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(36u32);
pub const NPFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(37u32);
pub const CDFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(38u32);
pub const RDR_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(39u32);
pub const CORRUPT_ACCESS_TOKEN: BUGCHECK_ERROR = BUGCHECK_ERROR(40u32);
pub const SECURITY_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(41u32);
pub const INCONSISTENT_IRP: BUGCHECK_ERROR = BUGCHECK_ERROR(42u32);
pub const PANIC_STACK_SWITCH: BUGCHECK_ERROR = BUGCHECK_ERROR(43u32);
pub const PORT_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(44u32);
pub const SCSI_DISK_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(45u32);
pub const DATA_BUS_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(46u32);
pub const INSTRUCTION_BUS_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(47u32);
pub const SET_OF_INVALID_CONTEXT: BUGCHECK_ERROR = BUGCHECK_ERROR(48u32);
pub const PHASE0_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(49u32);
pub const PHASE1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(50u32);
pub const UNEXPECTED_INITIALIZATION_CALL: BUGCHECK_ERROR = BUGCHECK_ERROR(51u32);
pub const CACHE_MANAGER: BUGCHECK_ERROR = BUGCHECK_ERROR(52u32);
pub const NO_MORE_IRP_STACK_LOCATIONS: BUGCHECK_ERROR = BUGCHECK_ERROR(53u32);
pub const DEVICE_REFERENCE_COUNT_NOT_ZERO: BUGCHECK_ERROR = BUGCHECK_ERROR(54u32);
pub const FLOPPY_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(55u32);
pub const SERIAL_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(56u32);
pub const SYSTEM_EXIT_OWNED_MUTEX: BUGCHECK_ERROR = BUGCHECK_ERROR(57u32);
pub const SYSTEM_UNWIND_PREVIOUS_USER: BUGCHECK_ERROR = BUGCHECK_ERROR(58u32);
pub const SYSTEM_SERVICE_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(59u32);
pub const INTERRUPT_UNWIND_ATTEMPTED: BUGCHECK_ERROR = BUGCHECK_ERROR(60u32);
pub const INTERRUPT_EXCEPTION_NOT_HANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(61u32);
pub const MULTIPROCESSOR_CONFIGURATION_NOT_SUPPORTED: BUGCHECK_ERROR = BUGCHECK_ERROR(62u32);
pub const NO_MORE_SYSTEM_PTES: BUGCHECK_ERROR = BUGCHECK_ERROR(63u32);
pub const TARGET_MDL_TOO_SMALL: BUGCHECK_ERROR = BUGCHECK_ERROR(64u32);
pub const MUST_SUCCEED_POOL_EMPTY: BUGCHECK_ERROR = BUGCHECK_ERROR(65u32);
pub const ATDISK_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(66u32);
pub const NO_SUCH_PARTITION: BUGCHECK_ERROR = BUGCHECK_ERROR(67u32);
pub const MULTIPLE_IRP_COMPLETE_REQUESTS: BUGCHECK_ERROR = BUGCHECK_ERROR(68u32);
pub const INSUFFICIENT_SYSTEM_MAP_REGS: BUGCHECK_ERROR = BUGCHECK_ERROR(69u32);
pub const DEREF_UNKNOWN_LOGON_SESSION: BUGCHECK_ERROR = BUGCHECK_ERROR(70u32);
pub const REF_UNKNOWN_LOGON_SESSION: BUGCHECK_ERROR = BUGCHECK_ERROR(71u32);
pub const CANCEL_STATE_IN_COMPLETED_IRP: BUGCHECK_ERROR = BUGCHECK_ERROR(72u32);
pub const PAGE_FAULT_WITH_INTERRUPTS_OFF: BUGCHECK_ERROR = BUGCHECK_ERROR(73u32);
pub const IRQL_GT_ZERO_AT_SYSTEM_SERVICE: BUGCHECK_ERROR = BUGCHECK_ERROR(74u32);
pub const STREAMS_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(75u32);
pub const FATAL_UNHANDLED_HARD_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(76u32);
pub const NO_PAGES_AVAILABLE: BUGCHECK_ERROR = BUGCHECK_ERROR(77u32);
pub const PFN_LIST_CORRUPT: BUGCHECK_ERROR = BUGCHECK_ERROR(78u32);
pub const NDIS_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(79u32);
pub const PAGE_FAULT_IN_NONPAGED_AREA: BUGCHECK_ERROR = BUGCHECK_ERROR(80u32);
pub const PAGE_FAULT_IN_NONPAGED_AREA_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435536u32);
pub const REGISTRY_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(81u32);
pub const MAILSLOT_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(82u32);
pub const NO_BOOT_DEVICE: BUGCHECK_ERROR = BUGCHECK_ERROR(83u32);
pub const LM_SERVER_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(84u32);
pub const DATA_COHERENCY_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(85u32);
pub const INSTRUCTION_COHERENCY_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(86u32);
pub const XNS_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(87u32);
pub const VOLMGRX_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(88u32);
pub const PINBALL_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(89u32);
pub const CRITICAL_SERVICE_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(90u32);
pub const SET_ENV_VAR_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(91u32);
pub const HAL_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(92u32);
pub const UNSUPPORTED_PROCESSOR: BUGCHECK_ERROR = BUGCHECK_ERROR(93u32);
pub const OBJECT_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(94u32);
pub const SECURITY_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(95u32);
pub const PROCESS_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(96u32);
pub const HAL1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(97u32);
pub const OBJECT1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(98u32);
pub const SECURITY1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(99u32);
pub const SYMBOLIC_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(100u32);
pub const MEMORY1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(101u32);
pub const CACHE_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(102u32);
pub const CONFIG_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(103u32);
pub const FILE_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(104u32);
pub const IO1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(105u32);
pub const LPC_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(106u32);
pub const PROCESS1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(107u32);
pub const REFMON_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(108u32);
pub const SESSION1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(109u32);
pub const BOOTPROC_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(110u32);
pub const VSL_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(111u32);
pub const SOFT_RESTART_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(112u32);
pub const ASSIGN_DRIVE_LETTERS_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(114u32);
pub const CONFIG_LIST_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(115u32);
pub const BAD_SYSTEM_CONFIG_INFO: BUGCHECK_ERROR = BUGCHECK_ERROR(116u32);
pub const CANNOT_WRITE_CONFIGURATION: BUGCHECK_ERROR = BUGCHECK_ERROR(117u32);
pub const PROCESS_HAS_LOCKED_PAGES: BUGCHECK_ERROR = BUGCHECK_ERROR(118u32);
pub const KERNEL_STACK_INPAGE_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(119u32);
pub const PHASE0_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(120u32);
pub const MISMATCHED_HAL: BUGCHECK_ERROR = BUGCHECK_ERROR(121u32);
pub const KERNEL_DATA_INPAGE_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(122u32);
pub const INACCESSIBLE_BOOT_DEVICE: BUGCHECK_ERROR = BUGCHECK_ERROR(123u32);
pub const BUGCODE_NDIS_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(124u32);
pub const INSTALL_MORE_MEMORY: BUGCHECK_ERROR = BUGCHECK_ERROR(125u32);
pub const SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(126u32);
pub const SYSTEM_THREAD_EXCEPTION_NOT_HANDLED_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435582u32);
pub const UNEXPECTED_KERNEL_MODE_TRAP: BUGCHECK_ERROR = BUGCHECK_ERROR(127u32);
pub const UNEXPECTED_KERNEL_MODE_TRAP_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435583u32);
pub const NMI_HARDWARE_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(128u32);
pub const SPIN_LOCK_INIT_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(129u32);
pub const DFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(130u32);
pub const OFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(131u32);
pub const RECOM_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(132u32);
pub const SETUP_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(133u32);
pub const AUDIT_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(134u32);
pub const MBR_CHECKSUM_MISMATCH: BUGCHECK_ERROR = BUGCHECK_ERROR(139u32);
pub const KERNEL_MODE_EXCEPTION_NOT_HANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(142u32);
pub const KERNEL_MODE_EXCEPTION_NOT_HANDLED_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435598u32);
pub const PP0_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(143u32);
pub const PP1_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(144u32);
pub const WIN32K_INIT_OR_RIT_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(145u32);
pub const UP_DRIVER_ON_MP_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(146u32);
pub const INVALID_KERNEL_HANDLE: BUGCHECK_ERROR = BUGCHECK_ERROR(147u32);
pub const KERNEL_STACK_LOCKED_AT_EXIT: BUGCHECK_ERROR = BUGCHECK_ERROR(148u32);
pub const PNP_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(149u32);
pub const INVALID_WORK_QUEUE_ITEM: BUGCHECK_ERROR = BUGCHECK_ERROR(150u32);
pub const BOUND_IMAGE_UNSUPPORTED: BUGCHECK_ERROR = BUGCHECK_ERROR(151u32);
pub const END_OF_NT_EVALUATION_PERIOD: BUGCHECK_ERROR = BUGCHECK_ERROR(152u32);
pub const INVALID_REGION_OR_SEGMENT: BUGCHECK_ERROR = BUGCHECK_ERROR(153u32);
pub const SYSTEM_LICENSE_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(154u32);
pub const UDFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(155u32);
pub const MACHINE_CHECK_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(156u32);
pub const USER_MODE_HEALTH_MONITOR: BUGCHECK_ERROR = BUGCHECK_ERROR(158u32);
pub const DRIVER_POWER_STATE_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(159u32);
pub const INTERNAL_POWER_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(160u32);
pub const PCI_BUS_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(161u32);
pub const MEMORY_IMAGE_CORRUPT: BUGCHECK_ERROR = BUGCHECK_ERROR(162u32);
pub const ACPI_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(163u32);
pub const CNSS_FILE_SYSTEM_FILTER: BUGCHECK_ERROR = BUGCHECK_ERROR(164u32);
pub const ACPI_BIOS_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(165u32);
pub const FP_EMULATION_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(166u32);
pub const BAD_EXHANDLE: BUGCHECK_ERROR = BUGCHECK_ERROR(167u32);
pub const BOOTING_IN_SAFEMODE_MINIMAL: BUGCHECK_ERROR = BUGCHECK_ERROR(168u32);
pub const BOOTING_IN_SAFEMODE_NETWORK: BUGCHECK_ERROR = BUGCHECK_ERROR(169u32);
pub const BOOTING_IN_SAFEMODE_DSREPAIR: BUGCHECK_ERROR = BUGCHECK_ERROR(170u32);
pub const SESSION_HAS_VALID_POOL_ON_EXIT: BUGCHECK_ERROR = BUGCHECK_ERROR(171u32);
pub const HAL_MEMORY_ALLOCATION: BUGCHECK_ERROR = BUGCHECK_ERROR(172u32);
pub const VIDEO_DRIVER_DEBUG_REPORT_REQUEST: BUGCHECK_ERROR = BUGCHECK_ERROR(1073741997u32);
pub const BGI_DETECTED_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(177u32);
pub const VIDEO_DRIVER_INIT_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(180u32);
pub const BOOTLOG_LOADED: BUGCHECK_ERROR = BUGCHECK_ERROR(181u32);
pub const BOOTLOG_NOT_LOADED: BUGCHECK_ERROR = BUGCHECK_ERROR(182u32);
pub const BOOTLOG_ENABLED: BUGCHECK_ERROR = BUGCHECK_ERROR(183u32);
pub const ATTEMPTED_SWITCH_FROM_DPC: BUGCHECK_ERROR = BUGCHECK_ERROR(184u32);
pub const CHIPSET_DETECTED_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(185u32);
pub const SESSION_HAS_VALID_VIEWS_ON_EXIT: BUGCHECK_ERROR = BUGCHECK_ERROR(186u32);
pub const NETWORK_BOOT_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(187u32);
pub const NETWORK_BOOT_DUPLICATE_ADDRESS: BUGCHECK_ERROR = BUGCHECK_ERROR(188u32);
pub const INVALID_HIBERNATED_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(189u32);
pub const ATTEMPTED_WRITE_TO_READONLY_MEMORY: BUGCHECK_ERROR = BUGCHECK_ERROR(190u32);
pub const MUTEX_ALREADY_OWNED: BUGCHECK_ERROR = BUGCHECK_ERROR(191u32);
pub const PCI_CONFIG_SPACE_ACCESS_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(192u32);
pub const SPECIAL_POOL_DETECTED_MEMORY_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(193u32);
pub const BAD_POOL_CALLER: BUGCHECK_ERROR = BUGCHECK_ERROR(194u32);
pub const SYSTEM_IMAGE_BAD_SIGNATURE: BUGCHECK_ERROR = BUGCHECK_ERROR(195u32);
pub const DRIVER_VERIFIER_DETECTED_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(196u32);
pub const DRIVER_CORRUPTED_EXPOOL: BUGCHECK_ERROR = BUGCHECK_ERROR(197u32);
pub const DRIVER_CAUGHT_MODIFYING_FREED_POOL: BUGCHECK_ERROR = BUGCHECK_ERROR(198u32);
pub const TIMER_OR_DPC_INVALID: BUGCHECK_ERROR = BUGCHECK_ERROR(199u32);
pub const IRQL_UNEXPECTED_VALUE: BUGCHECK_ERROR = BUGCHECK_ERROR(200u32);
pub const DRIVER_VERIFIER_IOMANAGER_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(201u32);
pub const PNP_DETECTED_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(202u32);
pub const DRIVER_LEFT_LOCKED_PAGES_IN_PROCESS: BUGCHECK_ERROR = BUGCHECK_ERROR(203u32);
pub const PAGE_FAULT_IN_FREED_SPECIAL_POOL: BUGCHECK_ERROR = BUGCHECK_ERROR(204u32);
pub const PAGE_FAULT_BEYOND_END_OF_ALLOCATION: BUGCHECK_ERROR = BUGCHECK_ERROR(205u32);
pub const DRIVER_UNLOADED_WITHOUT_CANCELLING_PENDING_OPERATIONS: BUGCHECK_ERROR = BUGCHECK_ERROR(206u32);
pub const TERMINAL_SERVER_DRIVER_MADE_INCORRECT_MEMORY_REFERENCE: BUGCHECK_ERROR = BUGCHECK_ERROR(207u32);
pub const DRIVER_CORRUPTED_MMPOOL: BUGCHECK_ERROR = BUGCHECK_ERROR(208u32);
pub const DRIVER_IRQL_NOT_LESS_OR_EQUAL: BUGCHECK_ERROR = BUGCHECK_ERROR(209u32);
pub const BUGCODE_ID_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(210u32);
pub const DRIVER_PORTION_MUST_BE_NONPAGED: BUGCHECK_ERROR = BUGCHECK_ERROR(211u32);
pub const SYSTEM_SCAN_AT_RAISED_IRQL_CAUGHT_IMPROPER_DRIVER_UNLOAD: BUGCHECK_ERROR = BUGCHECK_ERROR(212u32);
pub const DRIVER_PAGE_FAULT_IN_FREED_SPECIAL_POOL: BUGCHECK_ERROR = BUGCHECK_ERROR(213u32);
pub const DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION: BUGCHECK_ERROR = BUGCHECK_ERROR(214u32);
pub const DRIVER_PAGE_FAULT_BEYOND_END_OF_ALLOCATION_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435670u32);
pub const DRIVER_UNMAPPING_INVALID_VIEW: BUGCHECK_ERROR = BUGCHECK_ERROR(215u32);
pub const DRIVER_USED_EXCESSIVE_PTES: BUGCHECK_ERROR = BUGCHECK_ERROR(216u32);
pub const LOCKED_PAGES_TRACKER_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(217u32);
pub const SYSTEM_PTE_MISUSE: BUGCHECK_ERROR = BUGCHECK_ERROR(218u32);
pub const DRIVER_CORRUPTED_SYSPTES: BUGCHECK_ERROR = BUGCHECK_ERROR(219u32);
pub const DRIVER_INVALID_STACK_ACCESS: BUGCHECK_ERROR = BUGCHECK_ERROR(220u32);
pub const POOL_CORRUPTION_IN_FILE_AREA: BUGCHECK_ERROR = BUGCHECK_ERROR(222u32);
pub const IMPERSONATING_WORKER_THREAD: BUGCHECK_ERROR = BUGCHECK_ERROR(223u32);
pub const ACPI_BIOS_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(224u32);
pub const WORKER_THREAD_RETURNED_AT_BAD_IRQL: BUGCHECK_ERROR = BUGCHECK_ERROR(225u32);
pub const MANUALLY_INITIATED_CRASH: BUGCHECK_ERROR = BUGCHECK_ERROR(226u32);
pub const RESOURCE_NOT_OWNED: BUGCHECK_ERROR = BUGCHECK_ERROR(227u32);
pub const WORKER_INVALID: BUGCHECK_ERROR = BUGCHECK_ERROR(228u32);
pub const POWER_FAILURE_SIMULATE: BUGCHECK_ERROR = BUGCHECK_ERROR(229u32);
pub const DRIVER_VERIFIER_DMA_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(230u32);
pub const INVALID_FLOATING_POINT_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(231u32);
pub const INVALID_CANCEL_OF_FILE_OPEN: BUGCHECK_ERROR = BUGCHECK_ERROR(232u32);
pub const ACTIVE_EX_WORKER_THREAD_TERMINATION: BUGCHECK_ERROR = BUGCHECK_ERROR(233u32);
pub const SAVER_UNSPECIFIED: BUGCHECK_ERROR = BUGCHECK_ERROR(61440u32);
pub const SAVER_BLANKSCREEN: BUGCHECK_ERROR = BUGCHECK_ERROR(61442u32);
pub const SAVER_INPUT: BUGCHECK_ERROR = BUGCHECK_ERROR(61443u32);
pub const SAVER_WATCHDOG: BUGCHECK_ERROR = BUGCHECK_ERROR(61444u32);
pub const SAVER_STARTNOTVISIBLE: BUGCHECK_ERROR = BUGCHECK_ERROR(61445u32);
pub const SAVER_NAVIGATIONMODEL: BUGCHECK_ERROR = BUGCHECK_ERROR(61446u32);
pub const SAVER_OUTOFMEMORY: BUGCHECK_ERROR = BUGCHECK_ERROR(61447u32);
pub const SAVER_GRAPHICS: BUGCHECK_ERROR = BUGCHECK_ERROR(61448u32);
pub const SAVER_NAVSERVERTIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(61449u32);
pub const SAVER_CHROMEPROCESSCRASH: BUGCHECK_ERROR = BUGCHECK_ERROR(61450u32);
pub const SAVER_NOTIFICATIONDISMISSAL: BUGCHECK_ERROR = BUGCHECK_ERROR(61451u32);
pub const SAVER_SPEECHDISMISSAL: BUGCHECK_ERROR = BUGCHECK_ERROR(61452u32);
pub const SAVER_CALLDISMISSAL: BUGCHECK_ERROR = BUGCHECK_ERROR(61453u32);
pub const SAVER_APPBARDISMISSAL: BUGCHECK_ERROR = BUGCHECK_ERROR(61454u32);
pub const SAVER_RILADAPTATIONCRASH: BUGCHECK_ERROR = BUGCHECK_ERROR(61455u32);
pub const SAVER_APPLISTUNREACHABLE: BUGCHECK_ERROR = BUGCHECK_ERROR(61456u32);
pub const SAVER_REPORTNOTIFICATIONFAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(61457u32);
pub const SAVER_UNEXPECTEDSHUTDOWN: BUGCHECK_ERROR = BUGCHECK_ERROR(61458u32);
pub const SAVER_RPCFAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(61459u32);
pub const SAVER_AUXILIARYFULLDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(61460u32);
pub const SAVER_ACCOUNTPROVSVCINITFAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(61461u32);
pub const SAVER_MTBFCOMMANDTIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(789u32);
pub const SAVER_MTBFCOMMANDHANG: BUGCHECK_ERROR = BUGCHECK_ERROR(61697u32);
pub const SAVER_MTBFPASSBUGCHECK: BUGCHECK_ERROR = BUGCHECK_ERROR(61698u32);
pub const SAVER_MTBFIOERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(61699u32);
pub const SAVER_RENDERTHREADHANG: BUGCHECK_ERROR = BUGCHECK_ERROR(61952u32);
pub const SAVER_RENDERMOBILEUIOOM: BUGCHECK_ERROR = BUGCHECK_ERROR(61953u32);
pub const SAVER_DEVICEUPDATEUNSPECIFIED: BUGCHECK_ERROR = BUGCHECK_ERROR(62208u32);
pub const SAVER_AUDIODRIVERHANG: BUGCHECK_ERROR = BUGCHECK_ERROR(62464u32);
pub const SAVER_BATTERYPULLOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(62720u32);
pub const SAVER_MEDIACORETESTHANG: BUGCHECK_ERROR = BUGCHECK_ERROR(62976u32);
pub const SAVER_RESOURCEMANAGEMENT: BUGCHECK_ERROR = BUGCHECK_ERROR(63232u32);
pub const SAVER_CAPTURESERVICE: BUGCHECK_ERROR = BUGCHECK_ERROR(63488u32);
pub const SAVER_WAITFORSHELLREADY: BUGCHECK_ERROR = BUGCHECK_ERROR(63744u32);
pub const SAVER_NONRESPONSIVEPROCESS: BUGCHECK_ERROR = BUGCHECK_ERROR(404u32);
pub const SAVER_SICKAPPLICATION: BUGCHECK_ERROR = BUGCHECK_ERROR(34918u32);
pub const THREAD_STUCK_IN_DEVICE_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(234u32);
pub const THREAD_STUCK_IN_DEVICE_DRIVER_M: BUGCHECK_ERROR = BUGCHECK_ERROR(268435690u32);
pub const DIRTY_MAPPED_PAGES_CONGESTION: BUGCHECK_ERROR = BUGCHECK_ERROR(235u32);
pub const SESSION_HAS_VALID_SPECIAL_POOL_ON_EXIT: BUGCHECK_ERROR = BUGCHECK_ERROR(236u32);
pub const UNMOUNTABLE_BOOT_VOLUME: BUGCHECK_ERROR = BUGCHECK_ERROR(237u32);
pub const CRITICAL_PROCESS_DIED: BUGCHECK_ERROR = BUGCHECK_ERROR(239u32);
pub const STORAGE_MINIPORT_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(240u32);
pub const SCSI_VERIFIER_DETECTED_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(241u32);
pub const HARDWARE_INTERRUPT_STORM: BUGCHECK_ERROR = BUGCHECK_ERROR(242u32);
pub const DISORDERLY_SHUTDOWN: BUGCHECK_ERROR = BUGCHECK_ERROR(243u32);
pub const CRITICAL_OBJECT_TERMINATION: BUGCHECK_ERROR = BUGCHECK_ERROR(244u32);
pub const FLTMGR_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(245u32);
pub const PCI_VERIFIER_DETECTED_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(246u32);
pub const DRIVER_OVERRAN_STACK_BUFFER: BUGCHECK_ERROR = BUGCHECK_ERROR(247u32);
pub const RAMDISK_BOOT_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(248u32);
pub const DRIVER_RETURNED_STATUS_REPARSE_FOR_VOLUME_OPEN: BUGCHECK_ERROR = BUGCHECK_ERROR(249u32);
pub const HTTP_DRIVER_CORRUPTED: BUGCHECK_ERROR = BUGCHECK_ERROR(250u32);
pub const RECURSIVE_MACHINE_CHECK: BUGCHECK_ERROR = BUGCHECK_ERROR(251u32);
pub const ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY: BUGCHECK_ERROR = BUGCHECK_ERROR(252u32);
pub const DIRTY_NOWRITE_PAGES_CONGESTION: BUGCHECK_ERROR = BUGCHECK_ERROR(253u32);
pub const BUGCODE_USB_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(254u32);
pub const BC_BLUETOOTH_VERIFIER_FAULT: BUGCHECK_ERROR = BUGCHECK_ERROR(3070u32);
pub const BC_BTHMINI_VERIFIER_FAULT: BUGCHECK_ERROR = BUGCHECK_ERROR(3071u32);
pub const RESERVE_QUEUE_OVERFLOW: BUGCHECK_ERROR = BUGCHECK_ERROR(255u32);
pub const LOADER_BLOCK_MISMATCH: BUGCHECK_ERROR = BUGCHECK_ERROR(256u32);
pub const CLOCK_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(257u32);
pub const DPC_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(258u32);
pub const MUP_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(259u32);
pub const AGP_INVALID_ACCESS: BUGCHECK_ERROR = BUGCHECK_ERROR(260u32);
pub const AGP_GART_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(261u32);
pub const AGP_ILLEGALLY_REPROGRAMMED: BUGCHECK_ERROR = BUGCHECK_ERROR(262u32);
pub const KERNEL_EXPAND_STACK_ACTIVE: BUGCHECK_ERROR = BUGCHECK_ERROR(263u32);
pub const THIRD_PARTY_FILE_SYSTEM_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(264u32);
pub const CRITICAL_STRUCTURE_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(265u32);
pub const APP_TAGGING_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(266u32);
pub const DFSC_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(267u32);
pub const FSRTL_EXTRA_CREATE_PARAMETER_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(268u32);
pub const WDF_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(269u32);
pub const VIDEO_MEMORY_MANAGEMENT_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(270u32);
pub const DRIVER_INVALID_CRUNTIME_PARAMETER: BUGCHECK_ERROR = BUGCHECK_ERROR(272u32);
pub const RECURSIVE_NMI: BUGCHECK_ERROR = BUGCHECK_ERROR(273u32);
pub const MSRPC_STATE_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(274u32);
pub const VIDEO_DXGKRNL_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(275u32);
pub const VIDEO_SHADOW_DRIVER_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(276u32);
pub const AGP_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(277u32);
pub const VIDEO_TDR_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(278u32);
pub const VIDEO_TDR_TIMEOUT_DETECTED: BUGCHECK_ERROR = BUGCHECK_ERROR(279u32);
pub const NTHV_GUEST_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(280u32);
pub const VIDEO_SCHEDULER_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(281u32);
pub const EM_INITIALIZATION_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(282u32);
pub const DRIVER_RETURNED_HOLDING_CANCEL_LOCK: BUGCHECK_ERROR = BUGCHECK_ERROR(283u32);
pub const ATTEMPTED_WRITE_TO_CM_PROTECTED_STORAGE: BUGCHECK_ERROR = BUGCHECK_ERROR(284u32);
pub const EVENT_TRACING_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(285u32);
pub const TOO_MANY_RECURSIVE_FAULTS: BUGCHECK_ERROR = BUGCHECK_ERROR(286u32);
pub const INVALID_DRIVER_HANDLE: BUGCHECK_ERROR = BUGCHECK_ERROR(287u32);
pub const BITLOCKER_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(288u32);
pub const DRIVER_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(289u32);
pub const WHEA_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(290u32);
pub const CRYPTO_SELF_TEST_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(291u32);
pub const WHEA_UNCORRECTABLE_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(292u32);
pub const NMR_INVALID_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(293u32);
pub const NETIO_INVALID_POOL_CALLER: BUGCHECK_ERROR = BUGCHECK_ERROR(294u32);
pub const PAGE_NOT_ZERO: BUGCHECK_ERROR = BUGCHECK_ERROR(295u32);
pub const WORKER_THREAD_RETURNED_WITH_BAD_IO_PRIORITY: BUGCHECK_ERROR = BUGCHECK_ERROR(296u32);
pub const WORKER_THREAD_RETURNED_WITH_BAD_PAGING_IO_PRIORITY: BUGCHECK_ERROR = BUGCHECK_ERROR(297u32);
pub const MUI_NO_VALID_SYSTEM_LANGUAGE: BUGCHECK_ERROR = BUGCHECK_ERROR(298u32);
pub const FAULTY_HARDWARE_CORRUPTED_PAGE: BUGCHECK_ERROR = BUGCHECK_ERROR(299u32);
pub const EXFAT_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(300u32);
pub const VOLSNAP_OVERLAPPED_TABLE_ACCESS: BUGCHECK_ERROR = BUGCHECK_ERROR(301u32);
pub const INVALID_MDL_RANGE: BUGCHECK_ERROR = BUGCHECK_ERROR(302u32);
pub const VHD_BOOT_INITIALIZATION_FAILED: BUGCHECK_ERROR = BUGCHECK_ERROR(303u32);
pub const DYNAMIC_ADD_PROCESSOR_MISMATCH: BUGCHECK_ERROR = BUGCHECK_ERROR(304u32);
pub const INVALID_EXTENDED_PROCESSOR_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(305u32);
pub const RESOURCE_OWNER_POINTER_INVALID: BUGCHECK_ERROR = BUGCHECK_ERROR(306u32);
pub const DPC_WATCHDOG_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(307u32);
pub const DRIVE_EXTENDER: BUGCHECK_ERROR = BUGCHECK_ERROR(308u32);
pub const REGISTRY_FILTER_DRIVER_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(309u32);
pub const VHD_BOOT_HOST_VOLUME_NOT_ENOUGH_SPACE: BUGCHECK_ERROR = BUGCHECK_ERROR(310u32);
pub const WIN32K_HANDLE_MANAGER: BUGCHECK_ERROR = BUGCHECK_ERROR(311u32);
pub const GPIO_CONTROLLER_DRIVER_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(312u32);
pub const KERNEL_SECURITY_CHECK_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(313u32);
pub const KERNEL_MODE_HEAP_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(314u32);
pub const PASSIVE_INTERRUPT_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(315u32);
pub const INVALID_IO_BOOST_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(316u32);
pub const CRITICAL_INITIALIZATION_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(317u32);
pub const ERRATA_WORKAROUND_UNSUCCESSFUL: BUGCHECK_ERROR = BUGCHECK_ERROR(318u32);
pub const REGISTRY_CALLBACK_DRIVER_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(319u32);
pub const STORAGE_DEVICE_ABNORMALITY_DETECTED: BUGCHECK_ERROR = BUGCHECK_ERROR(320u32);
pub const VIDEO_ENGINE_TIMEOUT_DETECTED: BUGCHECK_ERROR = BUGCHECK_ERROR(321u32);
pub const VIDEO_TDR_APPLICATION_BLOCKED: BUGCHECK_ERROR = BUGCHECK_ERROR(322u32);
pub const PROCESSOR_DRIVER_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(323u32);
pub const BUGCODE_USB3_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(324u32);
pub const SECURE_BOOT_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(325u32);
pub const NDIS_NET_BUFFER_LIST_INFO_ILLEGALLY_TRANSFERRED: BUGCHECK_ERROR = BUGCHECK_ERROR(326u32);
pub const ABNORMAL_RESET_DETECTED: BUGCHECK_ERROR = BUGCHECK_ERROR(327u32);
pub const IO_OBJECT_INVALID: BUGCHECK_ERROR = BUGCHECK_ERROR(328u32);
pub const REFS_FILE_SYSTEM: BUGCHECK_ERROR = BUGCHECK_ERROR(329u32);
pub const KERNEL_WMI_INTERNAL: BUGCHECK_ERROR = BUGCHECK_ERROR(330u32);
pub const SOC_SUBSYSTEM_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(331u32);
pub const FATAL_ABNORMAL_RESET_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(332u32);
pub const EXCEPTION_SCOPE_INVALID: BUGCHECK_ERROR = BUGCHECK_ERROR(333u32);
pub const SOC_CRITICAL_DEVICE_REMOVED: BUGCHECK_ERROR = BUGCHECK_ERROR(334u32);
pub const PDC_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(335u32);
pub const TCPIP_AOAC_NIC_ACTIVE_REFERENCE_LEAK: BUGCHECK_ERROR = BUGCHECK_ERROR(336u32);
pub const UNSUPPORTED_INSTRUCTION_MODE: BUGCHECK_ERROR = BUGCHECK_ERROR(337u32);
pub const INVALID_PUSH_LOCK_FLAGS: BUGCHECK_ERROR = BUGCHECK_ERROR(338u32);
pub const KERNEL_LOCK_ENTRY_LEAKED_ON_THREAD_TERMINATION: BUGCHECK_ERROR = BUGCHECK_ERROR(339u32);
pub const UNEXPECTED_STORE_EXCEPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(340u32);
pub const OS_DATA_TAMPERING: BUGCHECK_ERROR = BUGCHECK_ERROR(341u32);
pub const WINSOCK_DETECTED_HUNG_CLOSESOCKET_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(342u32);
pub const KERNEL_THREAD_PRIORITY_FLOOR_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(343u32);
pub const ILLEGAL_IOMMU_PAGE_FAULT: BUGCHECK_ERROR = BUGCHECK_ERROR(344u32);
pub const HAL_ILLEGAL_IOMMU_PAGE_FAULT: BUGCHECK_ERROR = BUGCHECK_ERROR(345u32);
pub const SDBUS_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(346u32);
pub const WORKER_THREAD_RETURNED_WITH_SYSTEM_PAGE_PRIORITY_ACTIVE: BUGCHECK_ERROR = BUGCHECK_ERROR(347u32);
pub const PDC_WATCHDOG_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(348u32);
pub const SOC_SUBSYSTEM_FAILURE_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(349u32);
pub const BUGCODE_NDIS_DRIVER_LIVE_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(350u32);
pub const CONNECTED_STANDBY_WATCHDOG_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(351u32);
pub const WIN32K_ATOMIC_CHECK_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(352u32);
pub const LIVE_SYSTEM_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(353u32);
pub const KERNEL_AUTO_BOOST_INVALID_LOCK_RELEASE: BUGCHECK_ERROR = BUGCHECK_ERROR(354u32);
pub const WORKER_THREAD_TEST_CONDITION: BUGCHECK_ERROR = BUGCHECK_ERROR(355u32);
pub const WIN32K_CRITICAL_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(356u32);
pub const CLUSTER_CSV_STATUS_IO_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(357u32);
pub const CLUSTER_RESOURCE_CALL_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(358u32);
pub const CLUSTER_CSV_SNAPSHOT_DEVICE_INFO_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(359u32);
pub const CLUSTER_CSV_STATE_TRANSITION_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(360u32);
pub const CLUSTER_CSV_VOLUME_ARRIVAL_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(361u32);
pub const CLUSTER_CSV_VOLUME_REMOVAL_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(362u32);
pub const CLUSTER_CSV_CLUSTER_WATCHDOG_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(363u32);
pub const INVALID_RUNDOWN_PROTECTION_FLAGS: BUGCHECK_ERROR = BUGCHECK_ERROR(364u32);
pub const INVALID_SLOT_ALLOCATOR_FLAGS: BUGCHECK_ERROR = BUGCHECK_ERROR(365u32);
pub const ERESOURCE_INVALID_RELEASE: BUGCHECK_ERROR = BUGCHECK_ERROR(366u32);
pub const CLUSTER_CSV_STATE_TRANSITION_INTERVAL_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(367u32);
pub const CLUSTER_CSV_CLUSSVC_DISCONNECT_WATCHDOG: BUGCHECK_ERROR = BUGCHECK_ERROR(368u32);
pub const CRYPTO_LIBRARY_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(369u32);
pub const COREMSGCALL_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(371u32);
pub const COREMSG_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(372u32);
pub const PREVIOUS_FATAL_ABNORMAL_RESET_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(373u32);
pub const ELAM_DRIVER_DETECTED_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(376u32);
pub const CLUSTER_CLUSPORT_STATUS_IO_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(377u32);
pub const PROFILER_CONFIGURATION_ILLEGAL: BUGCHECK_ERROR = BUGCHECK_ERROR(379u32);
pub const PDC_LOCK_WATCHDOG_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(380u32);
pub const PDC_UNEXPECTED_REVOCATION_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(381u32);
pub const MICROCODE_REVISION_MISMATCH: BUGCHECK_ERROR = BUGCHECK_ERROR(382u32);
pub const HYPERGUARD_INITIALIZATION_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(383u32);
pub const WVR_LIVEDUMP_REPLICATION_IOCONTEXT_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(384u32);
pub const WVR_LIVEDUMP_STATE_TRANSITION_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(385u32);
pub const WVR_LIVEDUMP_RECOVERY_IOCONTEXT_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(386u32);
pub const WVR_LIVEDUMP_APP_IO_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(387u32);
pub const WVR_LIVEDUMP_MANUALLY_INITIATED: BUGCHECK_ERROR = BUGCHECK_ERROR(388u32);
pub const WVR_LIVEDUMP_STATE_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(389u32);
pub const WVR_LIVEDUMP_CRITICAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(390u32);
pub const VIDEO_DWMINIT_TIMEOUT_FALLBACK_BDD: BUGCHECK_ERROR = BUGCHECK_ERROR(391u32);
pub const CLUSTER_CSVFS_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(392u32);
pub const BAD_OBJECT_HEADER: BUGCHECK_ERROR = BUGCHECK_ERROR(393u32);
pub const SILO_CORRUPT: BUGCHECK_ERROR = BUGCHECK_ERROR(394u32);
pub const SECURE_KERNEL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(395u32);
pub const HYPERGUARD_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(396u32);
pub const SECURE_FAULT_UNHANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(397u32);
pub const KERNEL_PARTITION_REFERENCE_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(398u32);
pub const SYNTHETIC_EXCEPTION_UNHANDLED: BUGCHECK_ERROR = BUGCHECK_ERROR(399u32);
pub const WIN32K_CRITICAL_FAILURE_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(400u32);
pub const PF_DETECTED_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(401u32);
pub const KERNEL_AUTO_BOOST_LOCK_ACQUISITION_WITH_RAISED_IRQL: BUGCHECK_ERROR = BUGCHECK_ERROR(402u32);
pub const VIDEO_DXGKRNL_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(403u32);
pub const KERNEL_STORAGE_SLOT_IN_USE: BUGCHECK_ERROR = BUGCHECK_ERROR(409u32);
pub const SMB_SERVER_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(405u32);
pub const LOADER_ROLLBACK_DETECTED: BUGCHECK_ERROR = BUGCHECK_ERROR(406u32);
pub const WIN32K_SECURITY_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(407u32);
pub const UFX_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(408u32);
pub const WORKER_THREAD_RETURNED_WHILE_ATTACHED_TO_SILO: BUGCHECK_ERROR = BUGCHECK_ERROR(410u32);
pub const TTM_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(411u32);
pub const WIN32K_POWER_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(412u32);
pub const CLUSTER_SVHDX_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(413u32);
pub const BUGCODE_NETADAPTER_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(414u32);
pub const PDC_PRIVILEGE_CHECK_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(415u32);
pub const TTM_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(416u32);
pub const WIN32K_CALLOUT_WATCHDOG_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(417u32);
pub const WIN32K_CALLOUT_WATCHDOG_BUGCHECK: BUGCHECK_ERROR = BUGCHECK_ERROR(418u32);
pub const CALL_HAS_NOT_RETURNED_WATCHDOG_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(419u32);
pub const DRIPS_SW_HW_DIVERGENCE_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(420u32);
pub const USB_DRIPS_BLOCKER_SURPRISE_REMOVAL_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(421u32);
pub const BLUETOOTH_ERROR_RECOVERY_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(422u32);
pub const SMB_REDIRECTOR_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(423u32);
pub const VIDEO_DXGKRNL_BLACK_SCREEN_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(424u32);
pub const DIRECTED_FX_TRANSITION_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(425u32);
pub const EXCEPTION_ON_INVALID_STACK: BUGCHECK_ERROR = BUGCHECK_ERROR(426u32);
pub const UNWIND_ON_INVALID_STACK: BUGCHECK_ERROR = BUGCHECK_ERROR(427u32);
pub const VIDEO_MINIPORT_FAILED_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(432u32);
pub const VIDEO_MINIPORT_BLACK_SCREEN_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(440u32);
pub const DRIVER_VERIFIER_DETECTED_VIOLATION_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(452u32);
pub const IO_THREADPOOL_DEADLOCK_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(453u32);
pub const FAST_ERESOURCE_PRECONDITION_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(454u32);
pub const STORE_DATA_STRUCTURE_CORRUPTION: BUGCHECK_ERROR = BUGCHECK_ERROR(455u32);
pub const MANUALLY_INITIATED_POWER_BUTTON_HOLD: BUGCHECK_ERROR = BUGCHECK_ERROR(456u32);
pub const USER_MODE_HEALTH_MONITOR_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(457u32);
pub const SYNTHETIC_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(458u32);
pub const INVALID_SILO_DETACH: BUGCHECK_ERROR = BUGCHECK_ERROR(459u32);
pub const EXRESOURCE_TIMEOUT_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(460u32);
pub const INVALID_CALLBACK_STACK_ADDRESS: BUGCHECK_ERROR = BUGCHECK_ERROR(461u32);
pub const INVALID_KERNEL_STACK_ADDRESS: BUGCHECK_ERROR = BUGCHECK_ERROR(462u32);
pub const HARDWARE_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(463u32);
pub const ACPI_FIRMWARE_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(464u32);
pub const TELEMETRY_ASSERTS_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(465u32);
pub const WORKER_THREAD_INVALID_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(466u32);
pub const WFP_INVALID_OPERATION: BUGCHECK_ERROR = BUGCHECK_ERROR(467u32);
pub const UCMUCSI_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(468u32);
pub const DRIVER_PNP_WATCHDOG: BUGCHECK_ERROR = BUGCHECK_ERROR(469u32);
pub const WORKER_THREAD_RETURNED_WITH_NON_DEFAULT_WORKLOAD_CLASS: BUGCHECK_ERROR = BUGCHECK_ERROR(470u32);
pub const EFS_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(471u32);
pub const UCMUCSI_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(472u32);
pub const HAL_IOMMU_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(473u32);
pub const HAL_BLOCKED_PROCESSOR_INTERNAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(474u32);
pub const IPI_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(475u32);
pub const DMA_COMMON_BUFFER_VECTOR_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(476u32);
pub const BUGCODE_MBBADAPTER_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(477u32);
pub const BUGCODE_WIFIADAPTER_DRIVER: BUGCHECK_ERROR = BUGCHECK_ERROR(478u32);
pub const PROCESSOR_START_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(479u32);
pub const INVALID_ALTERNATE_SYSTEM_CALL_HANDLER_REGISTRATION: BUGCHECK_ERROR = BUGCHECK_ERROR(480u32);
pub const DEVICE_DIAGNOSTIC_LOG_LIVEDUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(481u32);
pub const AZURE_DEVICE_FW_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(482u32);
pub const BREAKAWAY_CABLE_TRANSITION: BUGCHECK_ERROR = BUGCHECK_ERROR(483u32);
pub const VIDEO_DXGKRNL_SYSMM_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(484u32);
pub const DRIVER_VERIFIER_TRACKING_LIVE_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(485u32);
pub const CRASHDUMP_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(486u32);
pub const REGISTRY_LIVE_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(487u32);
pub const INVALID_THREAD_AFFINITY_STATE: BUGCHECK_ERROR = BUGCHECK_ERROR(488u32);
pub const ILLEGAL_ATS_INITIALIZATION: BUGCHECK_ERROR = BUGCHECK_ERROR(489u32);
pub const SECURE_PCI_CONFIG_SPACE_ACCESS_VIOLATION: BUGCHECK_ERROR = BUGCHECK_ERROR(490u32);
pub const DAM_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(491u32);
pub const XBOX_VMCTRL_CS_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(854u32);
pub const XBOX_CORRUPTED_IMAGE: BUGCHECK_ERROR = BUGCHECK_ERROR(855u32);
pub const XBOX_INVERTED_FUNCTION_TABLE_OVERFLOW: BUGCHECK_ERROR = BUGCHECK_ERROR(856u32);
pub const XBOX_CORRUPTED_IMAGE_BASE: BUGCHECK_ERROR = BUGCHECK_ERROR(857u32);
pub const XBOX_XDS_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(858u32);
pub const XBOX_SHUTDOWN_WATCHDOG_TIMEOUT: BUGCHECK_ERROR = BUGCHECK_ERROR(859u32);
pub const XBOX_360_SYSTEM_CRASH: BUGCHECK_ERROR = BUGCHECK_ERROR(864u32);
pub const XBOX_360_SYSTEM_CRASH_RESERVED: BUGCHECK_ERROR = BUGCHECK_ERROR(1056u32);
pub const XBOX_SECURITY_FAILUE: BUGCHECK_ERROR = BUGCHECK_ERROR(1057u32);
pub const KERNEL_CFG_INIT_FAILURE: BUGCHECK_ERROR = BUGCHECK_ERROR(1058u32);
pub const MANUALLY_INITIATED_POWER_BUTTON_HOLD_LIVE_DUMP: BUGCHECK_ERROR = BUGCHECK_ERROR(4552u32);
pub const HYPERVISOR_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(131073u32);
pub const WINLOGON_FATAL_ERROR: BUGCHECK_ERROR = BUGCHECK_ERROR(3221226010u32);
pub const MANUALLY_INITIATED_CRASH1: BUGCHECK_ERROR = BUGCHECK_ERROR(3735936685u32);
pub const BUGCHECK_CONTEXT_MODIFIER: BUGCHECK_ERROR = BUGCHECK_ERROR(2147483648u32);
impl ::core::convert::From<u32> for BUGCHECK_ERROR {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for BUGCHECK_ERROR {
type Abi = Self;
}
impl ::core::ops::BitOr for BUGCHECK_ERROR {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for BUGCHECK_ERROR {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for BUGCHECK_ERROR {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for BUGCHECK_ERROR {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for BUGCHECK_ERROR {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Beep(dwfreq: u32, dwduration: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Beep(dwfreq: u32, dwduration: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(Beep(::core::mem::transmute(dwfreq), ::core::mem::transmute(dwduration)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn BindImage<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(imagename: Param0, dllpath: Param1, symbolpath: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn BindImage(imagename: super::super::super::Foundation::PSTR, dllpath: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(BindImage(imagename.into_param().abi(), dllpath.into_param().abi(), symbolpath.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn BindImageEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(flags: u32, imagename: Param1, dllpath: Param2, symbolpath: Param3, statusroutine: ::core::option::Option<PIMAGEHLP_STATUS_ROUTINE>) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn BindImageEx(flags: u32, imagename: super::super::super::Foundation::PSTR, dllpath: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, statusroutine: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(BindImageEx(::core::mem::transmute(flags), imagename.into_param().abi(), dllpath.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(statusroutine)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const CANNOT_ALLOCATE_MEMORY: u32 = 9u32;
pub const CATID_ActiveScript: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf0b7a1a1_9847_11cf_8f20_00805f2cd064);
pub const CATID_ActiveScriptAuthor: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0aee2a92_bcbb_11d0_8c72_00c04fc2b085);
pub const CATID_ActiveScriptEncode: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf0b7a1a3_9847_11cf_8f20_00805f2cd064);
pub const CATID_ActiveScriptParse: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf0b7a1a2_9847_11cf_8f20_00805f2cd064);
pub const CBA_CHECK_ARM_MACHINE_THUMB_TYPE_OVERRIDE: u32 = 2147483648u32;
pub const CBA_CHECK_ENGOPT_DISALLOW_NETWORK_PATHS: u32 = 1879048192u32;
pub const CBA_DEBUG_INFO: u32 = 268435456u32;
pub const CBA_DEFERRED_SYMBOL_LOAD_CANCEL: u32 = 7u32;
pub const CBA_DEFERRED_SYMBOL_LOAD_COMPLETE: u32 = 2u32;
pub const CBA_DEFERRED_SYMBOL_LOAD_FAILURE: u32 = 3u32;
pub const CBA_DEFERRED_SYMBOL_LOAD_PARTIAL: u32 = 32u32;
pub const CBA_DEFERRED_SYMBOL_LOAD_START: u32 = 1u32;
pub const CBA_DUPLICATE_SYMBOL: u32 = 5u32;
pub const CBA_ENGINE_PRESENT: u32 = 1610612736u32;
pub const CBA_EVENT: u32 = 16u32;
pub const CBA_MAP_JIT_SYMBOL: u32 = 2684354560u32;
pub const CBA_READ_MEMORY: u32 = 6u32;
pub const CBA_SET_OPTIONS: u32 = 8u32;
pub const CBA_SRCSRV_EVENT: u32 = 1073741824u32;
pub const CBA_SRCSRV_INFO: u32 = 536870912u32;
pub const CBA_SYMBOLS_UNLOADED: u32 = 4u32;
pub const CBA_UPDATE_STATUS_BAR: u32 = 1342177280u32;
pub const CBA_XML_LOG: u32 = 2415919104u32;
pub const CDebugDocumentHelper: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x83b8bca6_687c_11d0_a405_00aa0060275c);
pub const CERT_PE_IMAGE_DIGEST_ALL_IMPORT_INFO: u32 = 4u32;
pub const CERT_PE_IMAGE_DIGEST_DEBUG_INFO: u32 = 1u32;
pub const CERT_PE_IMAGE_DIGEST_NON_PE_INFO: u32 = 8u32;
pub const CERT_PE_IMAGE_DIGEST_RESOURCES: u32 = 2u32;
pub const CERT_SECTION_TYPE_ANY: u32 = 255u32;
pub const CHECKSUM_MAPVIEW_FAILURE: u32 = 3u32;
pub const CHECKSUM_MAP_FAILURE: u32 = 2u32;
pub const CHECKSUM_OPEN_FAILURE: u32 = 1u32;
pub const CHECKSUM_SUCCESS: u32 = 0u32;
pub const CHECKSUM_UNICODE_FAILURE: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub struct CONTEXT {
pub ContextFlags: u32,
pub Cpsr: u32,
pub Anonymous: CONTEXT_0,
pub Sp: u64,
pub Pc: u64,
pub V: [ARM64_NT_NEON128; 32],
pub Fpcr: u32,
pub Fpsr: u32,
pub Bcr: [u32; 8],
pub Bvr: [u64; 8],
pub Wcr: [u32; 2],
pub Wvr: [u64; 2],
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub union CONTEXT_0 {
pub Anonymous: CONTEXT_0_0,
pub X: [u64; 31],
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT_0 {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT_0 {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub struct CONTEXT_0_0 {
pub X0: u64,
pub X1: u64,
pub X2: u64,
pub X3: u64,
pub X4: u64,
pub X5: u64,
pub X6: u64,
pub X7: u64,
pub X8: u64,
pub X9: u64,
pub X10: u64,
pub X11: u64,
pub X12: u64,
pub X13: u64,
pub X14: u64,
pub X15: u64,
pub X16: u64,
pub X17: u64,
pub X18: u64,
pub X19: u64,
pub X20: u64,
pub X21: u64,
pub X22: u64,
pub X23: u64,
pub X24: u64,
pub X25: u64,
pub X26: u64,
pub X27: u64,
pub X28: u64,
pub Fp: u64,
pub Lr: u64,
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT_0_0 {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for CONTEXT_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct")
.field("X0", &self.X0)
.field("X1", &self.X1)
.field("X2", &self.X2)
.field("X3", &self.X3)
.field("X4", &self.X4)
.field("X5", &self.X5)
.field("X6", &self.X6)
.field("X7", &self.X7)
.field("X8", &self.X8)
.field("X9", &self.X9)
.field("X10", &self.X10)
.field("X11", &self.X11)
.field("X12", &self.X12)
.field("X13", &self.X13)
.field("X14", &self.X14)
.field("X15", &self.X15)
.field("X16", &self.X16)
.field("X17", &self.X17)
.field("X18", &self.X18)
.field("X19", &self.X19)
.field("X20", &self.X20)
.field("X21", &self.X21)
.field("X22", &self.X22)
.field("X23", &self.X23)
.field("X24", &self.X24)
.field("X25", &self.X25)
.field("X26", &self.X26)
.field("X27", &self.X27)
.field("X28", &self.X28)
.field("Fp", &self.Fp)
.field("Lr", &self.Lr)
.finish()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT_0_0 {
fn eq(&self, other: &Self) -> bool {
self.X0 == other.X0
&& self.X1 == other.X1
&& self.X2 == other.X2
&& self.X3 == other.X3
&& self.X4 == other.X4
&& self.X5 == other.X5
&& self.X6 == other.X6
&& self.X7 == other.X7
&& self.X8 == other.X8
&& self.X9 == other.X9
&& self.X10 == other.X10
&& self.X11 == other.X11
&& self.X12 == other.X12
&& self.X13 == other.X13
&& self.X14 == other.X14
&& self.X15 == other.X15
&& self.X16 == other.X16
&& self.X17 == other.X17
&& self.X18 == other.X18
&& self.X19 == other.X19
&& self.X20 == other.X20
&& self.X21 == other.X21
&& self.X22 == other.X22
&& self.X23 == other.X23
&& self.X24 == other.X24
&& self.X25 == other.X25
&& self.X26 == other.X26
&& self.X27 == other.X27
&& self.X28 == other.X28
&& self.Fp == other.Fp
&& self.Lr == other.Lr
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT_0_0 {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub struct CONTEXT {
pub P1Home: u64,
pub P2Home: u64,
pub P3Home: u64,
pub P4Home: u64,
pub P5Home: u64,
pub P6Home: u64,
pub ContextFlags: u32,
pub MxCsr: u32,
pub SegCs: u16,
pub SegDs: u16,
pub SegEs: u16,
pub SegFs: u16,
pub SegGs: u16,
pub SegSs: u16,
pub EFlags: u32,
pub Dr0: u64,
pub Dr1: u64,
pub Dr2: u64,
pub Dr3: u64,
pub Dr6: u64,
pub Dr7: u64,
pub Rax: u64,
pub Rcx: u64,
pub Rdx: u64,
pub Rbx: u64,
pub Rsp: u64,
pub Rbp: u64,
pub Rsi: u64,
pub Rdi: u64,
pub R8: u64,
pub R9: u64,
pub R10: u64,
pub R11: u64,
pub R12: u64,
pub R13: u64,
pub R14: u64,
pub R15: u64,
pub Rip: u64,
pub Anonymous: CONTEXT_0,
pub VectorRegister: [M128A; 26],
pub VectorControl: u64,
pub DebugControl: u64,
pub LastBranchToRip: u64,
pub LastBranchFromRip: u64,
pub LastExceptionToRip: u64,
pub LastExceptionFromRip: u64,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub union CONTEXT_0 {
pub FltSave: XSAVE_FORMAT,
pub Anonymous: CONTEXT_0_0,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT_0 {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT_0 {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
pub struct CONTEXT_0_0 {
pub Header: [M128A; 2],
pub Legacy: [M128A; 8],
pub Xmm0: M128A,
pub Xmm1: M128A,
pub Xmm2: M128A,
pub Xmm3: M128A,
pub Xmm4: M128A,
pub Xmm5: M128A,
pub Xmm6: M128A,
pub Xmm7: M128A,
pub Xmm8: M128A,
pub Xmm9: M128A,
pub Xmm10: M128A,
pub Xmm11: M128A,
pub Xmm12: M128A,
pub Xmm13: M128A,
pub Xmm14: M128A,
pub Xmm15: M128A,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT_0_0 {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for CONTEXT_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct")
.field("Header", &self.Header)
.field("Legacy", &self.Legacy)
.field("Xmm0", &self.Xmm0)
.field("Xmm1", &self.Xmm1)
.field("Xmm2", &self.Xmm2)
.field("Xmm3", &self.Xmm3)
.field("Xmm4", &self.Xmm4)
.field("Xmm5", &self.Xmm5)
.field("Xmm6", &self.Xmm6)
.field("Xmm7", &self.Xmm7)
.field("Xmm8", &self.Xmm8)
.field("Xmm9", &self.Xmm9)
.field("Xmm10", &self.Xmm10)
.field("Xmm11", &self.Xmm11)
.field("Xmm12", &self.Xmm12)
.field("Xmm13", &self.Xmm13)
.field("Xmm14", &self.Xmm14)
.field("Xmm15", &self.Xmm15)
.finish()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT_0_0 {
fn eq(&self, other: &Self) -> bool {
self.Header == other.Header
&& self.Legacy == other.Legacy
&& self.Xmm0 == other.Xmm0
&& self.Xmm1 == other.Xmm1
&& self.Xmm2 == other.Xmm2
&& self.Xmm3 == other.Xmm3
&& self.Xmm4 == other.Xmm4
&& self.Xmm5 == other.Xmm5
&& self.Xmm6 == other.Xmm6
&& self.Xmm7 == other.Xmm7
&& self.Xmm8 == other.Xmm8
&& self.Xmm9 == other.Xmm9
&& self.Xmm10 == other.Xmm10
&& self.Xmm11 == other.Xmm11
&& self.Xmm12 == other.Xmm12
&& self.Xmm13 == other.Xmm13
&& self.Xmm14 == other.Xmm14
&& self.Xmm15 == other.Xmm15
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT_0_0 {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
pub struct CONTEXT {
pub ContextFlags: u32,
pub Dr0: u32,
pub Dr1: u32,
pub Dr2: u32,
pub Dr3: u32,
pub Dr6: u32,
pub Dr7: u32,
pub FloatSave: super::super::Kernel::FLOATING_SAVE_AREA,
pub SegGs: u32,
pub SegFs: u32,
pub SegEs: u32,
pub SegDs: u32,
pub Edi: u32,
pub Esi: u32,
pub Ebx: u32,
pub Edx: u32,
pub Ecx: u32,
pub Eax: u32,
pub Ebp: u32,
pub Eip: u32,
pub SegCs: u32,
pub EFlags: u32,
pub Esp: u32,
pub SegSs: u32,
pub ExtendedRegisters: [u8; 512],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
impl CONTEXT {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("CONTEXT")
.field("ContextFlags", &self.ContextFlags)
.field("Dr0", &self.Dr0)
.field("Dr1", &self.Dr1)
.field("Dr2", &self.Dr2)
.field("Dr3", &self.Dr3)
.field("Dr6", &self.Dr6)
.field("Dr7", &self.Dr7)
.field("FloatSave", &self.FloatSave)
.field("SegGs", &self.SegGs)
.field("SegFs", &self.SegFs)
.field("SegEs", &self.SegEs)
.field("SegDs", &self.SegDs)
.field("Edi", &self.Edi)
.field("Esi", &self.Esi)
.field("Ebx", &self.Ebx)
.field("Edx", &self.Edx)
.field("Ecx", &self.Ecx)
.field("Eax", &self.Eax)
.field("Ebp", &self.Ebp)
.field("Eip", &self.Eip)
.field("SegCs", &self.SegCs)
.field("EFlags", &self.EFlags)
.field("Esp", &self.Esp)
.field("SegSs", &self.SegSs)
.field("ExtendedRegisters", &self.ExtendedRegisters)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.ContextFlags == other.ContextFlags
&& self.Dr0 == other.Dr0
&& self.Dr1 == other.Dr1
&& self.Dr2 == other.Dr2
&& self.Dr3 == other.Dr3
&& self.Dr6 == other.Dr6
&& self.Dr7 == other.Dr7
&& self.FloatSave == other.FloatSave
&& self.SegGs == other.SegGs
&& self.SegFs == other.SegFs
&& self.SegEs == other.SegEs
&& self.SegDs == other.SegDs
&& self.Edi == other.Edi
&& self.Esi == other.Esi
&& self.Ebx == other.Ebx
&& self.Edx == other.Edx
&& self.Ecx == other.Ecx
&& self.Eax == other.Eax
&& self.Ebp == other.Ebp
&& self.Eip == other.Eip
&& self.SegCs == other.SegCs
&& self.EFlags == other.EFlags
&& self.Esp == other.Esp
&& self.SegSs == other.SegSs
&& self.ExtendedRegisters == other.ExtendedRegisters
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for CONTEXT {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union CPU_INFORMATION {
pub X86CpuInfo: CPU_INFORMATION_1,
pub OtherCpuInfo: CPU_INFORMATION_0,
}
impl CPU_INFORMATION {}
impl ::core::default::Default for CPU_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for CPU_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for CPU_INFORMATION {}
unsafe impl ::windows::core::Abi for CPU_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct CPU_INFORMATION_0 {
pub ProcessorFeatures: [u64; 2],
}
impl CPU_INFORMATION_0 {}
impl ::core::default::Default for CPU_INFORMATION_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for CPU_INFORMATION_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for CPU_INFORMATION_0 {}
unsafe impl ::windows::core::Abi for CPU_INFORMATION_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct CPU_INFORMATION_1 {
pub VendorId: [u32; 3],
pub VersionInformation: u32,
pub FeatureInformation: u32,
pub AMDExtendedCpuFeatures: u32,
}
impl CPU_INFORMATION_1 {}
impl ::core::default::Default for CPU_INFORMATION_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for CPU_INFORMATION_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_X86CpuInfo_e__Struct").field("VendorId", &self.VendorId).field("VersionInformation", &self.VersionInformation).field("FeatureInformation", &self.FeatureInformation).field("AMDExtendedCpuFeatures", &self.AMDExtendedCpuFeatures).finish()
}
}
impl ::core::cmp::PartialEq for CPU_INFORMATION_1 {
fn eq(&self, other: &Self) -> bool {
self.VendorId == other.VendorId && self.VersionInformation == other.VersionInformation && self.FeatureInformation == other.FeatureInformation && self.AMDExtendedCpuFeatures == other.AMDExtendedCpuFeatures
}
}
impl ::core::cmp::Eq for CPU_INFORMATION_1 {}
unsafe impl ::windows::core::Abi for CPU_INFORMATION_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
pub struct CREATE_PROCESS_DEBUG_INFO {
pub hFile: super::super::super::Foundation::HANDLE,
pub hProcess: super::super::super::Foundation::HANDLE,
pub hThread: super::super::super::Foundation::HANDLE,
pub lpBaseOfImage: *mut ::core::ffi::c_void,
pub dwDebugInfoFileOffset: u32,
pub nDebugInfoSize: u32,
pub lpThreadLocalBase: *mut ::core::ffi::c_void,
pub lpStartAddress: ::core::option::Option<super::super::Threading::LPTHREAD_START_ROUTINE>,
pub lpImageName: *mut ::core::ffi::c_void,
pub fUnicode: u16,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl CREATE_PROCESS_DEBUG_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::default::Default for CREATE_PROCESS_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::fmt::Debug for CREATE_PROCESS_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("CREATE_PROCESS_DEBUG_INFO")
.field("hFile", &self.hFile)
.field("hProcess", &self.hProcess)
.field("hThread", &self.hThread)
.field("lpBaseOfImage", &self.lpBaseOfImage)
.field("dwDebugInfoFileOffset", &self.dwDebugInfoFileOffset)
.field("nDebugInfoSize", &self.nDebugInfoSize)
.field("lpThreadLocalBase", &self.lpThreadLocalBase)
.field("lpImageName", &self.lpImageName)
.field("fUnicode", &self.fUnicode)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::PartialEq for CREATE_PROCESS_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.hFile == other.hFile && self.hProcess == other.hProcess && self.hThread == other.hThread && self.lpBaseOfImage == other.lpBaseOfImage && self.dwDebugInfoFileOffset == other.dwDebugInfoFileOffset && self.nDebugInfoSize == other.nDebugInfoSize && self.lpThreadLocalBase == other.lpThreadLocalBase && self.lpStartAddress.map(|f| f as usize) == other.lpStartAddress.map(|f| f as usize) && self.lpImageName == other.lpImageName && self.fUnicode == other.fUnicode
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::Eq for CREATE_PROCESS_DEBUG_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
unsafe impl ::windows::core::Abi for CREATE_PROCESS_DEBUG_INFO {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
pub struct CREATE_THREAD_DEBUG_INFO {
pub hThread: super::super::super::Foundation::HANDLE,
pub lpThreadLocalBase: *mut ::core::ffi::c_void,
pub lpStartAddress: ::core::option::Option<super::super::Threading::LPTHREAD_START_ROUTINE>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl CREATE_THREAD_DEBUG_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::default::Default for CREATE_THREAD_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::fmt::Debug for CREATE_THREAD_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("CREATE_THREAD_DEBUG_INFO").field("hThread", &self.hThread).field("lpThreadLocalBase", &self.lpThreadLocalBase).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::PartialEq for CREATE_THREAD_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.hThread == other.hThread && self.lpThreadLocalBase == other.lpThreadLocalBase && self.lpStartAddress.map(|f| f as usize) == other.lpStartAddress.map(|f| f as usize)
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::Eq for CREATE_THREAD_DEBUG_INFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
unsafe impl ::windows::core::Abi for CREATE_THREAD_DEBUG_INFO {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const CROSS_PLATFORM_MAXIMUM_PROCESSORS: u32 = 2048u32;
pub const CURRENT_KD_SECONDARY_VERSION: u32 = 2u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct CallingConventionKind(pub i32);
pub const CallingConventionUnknown: CallingConventionKind = CallingConventionKind(0i32);
pub const CallingConventionCDecl: CallingConventionKind = CallingConventionKind(1i32);
pub const CallingConventionFastCall: CallingConventionKind = CallingConventionKind(2i32);
pub const CallingConventionStdCall: CallingConventionKind = CallingConventionKind(3i32);
pub const CallingConventionSysCall: CallingConventionKind = CallingConventionKind(4i32);
pub const CallingConventionThisCall: CallingConventionKind = CallingConventionKind(5i32);
impl ::core::convert::From<i32> for CallingConventionKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for CallingConventionKind {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn CheckRemoteDebuggerPresent<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, pbdebuggerpresent: *mut super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CheckRemoteDebuggerPresent(hprocess: super::super::super::Foundation::HANDLE, pbdebuggerpresent: *mut super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(CheckRemoteDebuggerPresent(hprocess.into_param().abi(), ::core::mem::transmute(pbdebuggerpresent)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn CheckSumMappedFile(baseaddress: *const ::core::ffi::c_void, filelength: u32, headersum: *mut u32, checksum: *mut u32) -> *mut IMAGE_NT_HEADERS64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CheckSumMappedFile(baseaddress: *const ::core::ffi::c_void, filelength: u32, headersum: *mut u32, checksum: *mut u32) -> *mut IMAGE_NT_HEADERS64;
}
::core::mem::transmute(CheckSumMappedFile(::core::mem::transmute(baseaddress), ::core::mem::transmute(filelength), ::core::mem::transmute(headersum), ::core::mem::transmute(checksum)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[inline]
pub unsafe fn CheckSumMappedFile(baseaddress: *const ::core::ffi::c_void, filelength: u32, headersum: *mut u32, checksum: *mut u32) -> *mut IMAGE_NT_HEADERS32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CheckSumMappedFile(baseaddress: *const ::core::ffi::c_void, filelength: u32, headersum: *mut u32, checksum: *mut u32) -> *mut IMAGE_NT_HEADERS32;
}
::core::mem::transmute(CheckSumMappedFile(::core::mem::transmute(baseaddress), ::core::mem::transmute(filelength), ::core::mem::transmute(headersum), ::core::mem::transmute(checksum)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn CloseThreadWaitChainSession(wcthandle: *const ::core::ffi::c_void) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CloseThreadWaitChainSession(wcthandle: *const ::core::ffi::c_void);
}
::core::mem::transmute(CloseThreadWaitChainSession(::core::mem::transmute(wcthandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ContinueDebugEvent(dwprocessid: u32, dwthreadid: u32, dwcontinuestatus: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ContinueDebugEvent(dwprocessid: u32, dwthreadid: u32, dwcontinuestatus: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ContinueDebugEvent(::core::mem::transmute(dwprocessid), ::core::mem::transmute(dwthreadid), ::core::mem::transmute(dwcontinuestatus)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn CopyContext(destination: *mut CONTEXT, contextflags: u32, source: *const CONTEXT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CopyContext(destination: *mut CONTEXT, contextflags: u32, source: *const CONTEXT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(CopyContext(::core::mem::transmute(destination), ::core::mem::transmute(contextflags), ::core::mem::transmute(source)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn CreateDataModelManager<'a, Param0: ::windows::core::IntoParam<'a, IDebugHost>>(debughost: Param0) -> ::windows::core::Result<IDataModelManager> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn CreateDataModelManager(debughost: ::windows::core::RawPtr, manager: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT;
}
let mut result__: <IDataModelManager as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
CreateDataModelManager(debughost.into_param().abi(), &mut result__).from_abi::<IDataModelManager>(result__)
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DBGHELP_DATA_REPORT_STRUCT {
pub pBinPathNonExist: super::super::super::Foundation::PWSTR,
pub pSymbolPathNonExist: super::super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl DBGHELP_DATA_REPORT_STRUCT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DBGHELP_DATA_REPORT_STRUCT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DBGHELP_DATA_REPORT_STRUCT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DBGHELP_DATA_REPORT_STRUCT").field("pBinPathNonExist", &self.pBinPathNonExist).field("pSymbolPathNonExist", &self.pSymbolPathNonExist).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DBGHELP_DATA_REPORT_STRUCT {
fn eq(&self, other: &Self) -> bool {
self.pBinPathNonExist == other.pBinPathNonExist && self.pSymbolPathNonExist == other.pSymbolPathNonExist
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DBGHELP_DATA_REPORT_STRUCT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DBGHELP_DATA_REPORT_STRUCT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_System_Kernel")]
pub struct DBGKD_DEBUG_DATA_HEADER32 {
pub List: super::super::Kernel::LIST_ENTRY32,
pub OwnerTag: u32,
pub Size: u32,
}
#[cfg(feature = "Win32_System_Kernel")]
impl DBGKD_DEBUG_DATA_HEADER32 {}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for DBGKD_DEBUG_DATA_HEADER32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for DBGKD_DEBUG_DATA_HEADER32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DBGKD_DEBUG_DATA_HEADER32").field("List", &self.List).field("OwnerTag", &self.OwnerTag).field("Size", &self.Size).finish()
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for DBGKD_DEBUG_DATA_HEADER32 {
fn eq(&self, other: &Self) -> bool {
self.List == other.List && self.OwnerTag == other.OwnerTag && self.Size == other.Size
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for DBGKD_DEBUG_DATA_HEADER32 {}
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for DBGKD_DEBUG_DATA_HEADER32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_System_Kernel")]
pub struct DBGKD_DEBUG_DATA_HEADER64 {
pub List: super::super::Kernel::LIST_ENTRY64,
pub OwnerTag: u32,
pub Size: u32,
}
#[cfg(feature = "Win32_System_Kernel")]
impl DBGKD_DEBUG_DATA_HEADER64 {}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for DBGKD_DEBUG_DATA_HEADER64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for DBGKD_DEBUG_DATA_HEADER64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DBGKD_DEBUG_DATA_HEADER64").field("List", &self.List).field("OwnerTag", &self.OwnerTag).field("Size", &self.Size).finish()
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for DBGKD_DEBUG_DATA_HEADER64 {
fn eq(&self, other: &Self) -> bool {
self.List == other.List && self.OwnerTag == other.OwnerTag && self.Size == other.Size
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for DBGKD_DEBUG_DATA_HEADER64 {}
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for DBGKD_DEBUG_DATA_HEADER64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DBGKD_GET_VERSION32 {
pub MajorVersion: u16,
pub MinorVersion: u16,
pub ProtocolVersion: u16,
pub Flags: u16,
pub KernBase: u32,
pub PsLoadedModuleList: u32,
pub MachineType: u16,
pub ThCallbackStack: u16,
pub NextCallback: u16,
pub FramePointer: u16,
pub KiCallUserMode: u32,
pub KeUserCallbackDispatcher: u32,
pub BreakpointWithStatus: u32,
pub DebuggerDataList: u32,
}
impl DBGKD_GET_VERSION32 {}
impl ::core::default::Default for DBGKD_GET_VERSION32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DBGKD_GET_VERSION32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DBGKD_GET_VERSION32")
.field("MajorVersion", &self.MajorVersion)
.field("MinorVersion", &self.MinorVersion)
.field("ProtocolVersion", &self.ProtocolVersion)
.field("Flags", &self.Flags)
.field("KernBase", &self.KernBase)
.field("PsLoadedModuleList", &self.PsLoadedModuleList)
.field("MachineType", &self.MachineType)
.field("ThCallbackStack", &self.ThCallbackStack)
.field("NextCallback", &self.NextCallback)
.field("FramePointer", &self.FramePointer)
.field("KiCallUserMode", &self.KiCallUserMode)
.field("KeUserCallbackDispatcher", &self.KeUserCallbackDispatcher)
.field("BreakpointWithStatus", &self.BreakpointWithStatus)
.field("DebuggerDataList", &self.DebuggerDataList)
.finish()
}
}
impl ::core::cmp::PartialEq for DBGKD_GET_VERSION32 {
fn eq(&self, other: &Self) -> bool {
self.MajorVersion == other.MajorVersion
&& self.MinorVersion == other.MinorVersion
&& self.ProtocolVersion == other.ProtocolVersion
&& self.Flags == other.Flags
&& self.KernBase == other.KernBase
&& self.PsLoadedModuleList == other.PsLoadedModuleList
&& self.MachineType == other.MachineType
&& self.ThCallbackStack == other.ThCallbackStack
&& self.NextCallback == other.NextCallback
&& self.FramePointer == other.FramePointer
&& self.KiCallUserMode == other.KiCallUserMode
&& self.KeUserCallbackDispatcher == other.KeUserCallbackDispatcher
&& self.BreakpointWithStatus == other.BreakpointWithStatus
&& self.DebuggerDataList == other.DebuggerDataList
}
}
impl ::core::cmp::Eq for DBGKD_GET_VERSION32 {}
unsafe impl ::windows::core::Abi for DBGKD_GET_VERSION32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DBGKD_GET_VERSION64 {
pub MajorVersion: u16,
pub MinorVersion: u16,
pub ProtocolVersion: u8,
pub KdSecondaryVersion: u8,
pub Flags: u16,
pub MachineType: u16,
pub MaxPacketType: u8,
pub MaxStateChange: u8,
pub MaxManipulate: u8,
pub Simulation: u8,
pub Unused: [u16; 1],
pub KernBase: u64,
pub PsLoadedModuleList: u64,
pub DebuggerDataList: u64,
}
impl DBGKD_GET_VERSION64 {}
impl ::core::default::Default for DBGKD_GET_VERSION64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DBGKD_GET_VERSION64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DBGKD_GET_VERSION64")
.field("MajorVersion", &self.MajorVersion)
.field("MinorVersion", &self.MinorVersion)
.field("ProtocolVersion", &self.ProtocolVersion)
.field("KdSecondaryVersion", &self.KdSecondaryVersion)
.field("Flags", &self.Flags)
.field("MachineType", &self.MachineType)
.field("MaxPacketType", &self.MaxPacketType)
.field("MaxStateChange", &self.MaxStateChange)
.field("MaxManipulate", &self.MaxManipulate)
.field("Simulation", &self.Simulation)
.field("Unused", &self.Unused)
.field("KernBase", &self.KernBase)
.field("PsLoadedModuleList", &self.PsLoadedModuleList)
.field("DebuggerDataList", &self.DebuggerDataList)
.finish()
}
}
impl ::core::cmp::PartialEq for DBGKD_GET_VERSION64 {
fn eq(&self, other: &Self) -> bool {
self.MajorVersion == other.MajorVersion
&& self.MinorVersion == other.MinorVersion
&& self.ProtocolVersion == other.ProtocolVersion
&& self.KdSecondaryVersion == other.KdSecondaryVersion
&& self.Flags == other.Flags
&& self.MachineType == other.MachineType
&& self.MaxPacketType == other.MaxPacketType
&& self.MaxStateChange == other.MaxStateChange
&& self.MaxManipulate == other.MaxManipulate
&& self.Simulation == other.Simulation
&& self.Unused == other.Unused
&& self.KernBase == other.KernBase
&& self.PsLoadedModuleList == other.PsLoadedModuleList
&& self.DebuggerDataList == other.DebuggerDataList
}
}
impl ::core::cmp::Eq for DBGKD_GET_VERSION64 {}
unsafe impl ::windows::core::Abi for DBGKD_GET_VERSION64 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DBGKD_MAJOR_TYPES(pub i32);
pub const DBGKD_MAJOR_NT: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(0i32);
pub const DBGKD_MAJOR_XBOX: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(1i32);
pub const DBGKD_MAJOR_BIG: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(2i32);
pub const DBGKD_MAJOR_EXDI: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(3i32);
pub const DBGKD_MAJOR_NTBD: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(4i32);
pub const DBGKD_MAJOR_EFI: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(5i32);
pub const DBGKD_MAJOR_TNT: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(6i32);
pub const DBGKD_MAJOR_SINGULARITY: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(7i32);
pub const DBGKD_MAJOR_HYPERVISOR: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(8i32);
pub const DBGKD_MAJOR_MIDORI: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(9i32);
pub const DBGKD_MAJOR_CE: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(10i32);
pub const DBGKD_MAJOR_COUNT: DBGKD_MAJOR_TYPES = DBGKD_MAJOR_TYPES(11i32);
impl ::core::convert::From<i32> for DBGKD_MAJOR_TYPES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DBGKD_MAJOR_TYPES {
type Abi = Self;
}
pub const DBGKD_SIMULATION_EXDI: i32 = 1i32;
pub const DBGKD_SIMULATION_NONE: i32 = 0i32;
pub const DBGKD_VERS_FLAG_DATA: u32 = 2u32;
pub const DBGKD_VERS_FLAG_HAL_IN_NTOS: u32 = 64u32;
pub const DBGKD_VERS_FLAG_HSS: u32 = 16u32;
pub const DBGKD_VERS_FLAG_MP: u32 = 1u32;
pub const DBGKD_VERS_FLAG_NOMM: u32 = 8u32;
pub const DBGKD_VERS_FLAG_PARTITIONS: u32 = 32u32;
pub const DBGKD_VERS_FLAG_PTR64: u32 = 4u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DBGPROP_ATTRIB_FLAGS(pub u32);
pub const DBGPROP_ATTRIB_NO_ATTRIB: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(0u32);
pub const DBGPROP_ATTRIB_VALUE_IS_INVALID: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(8u32);
pub const DBGPROP_ATTRIB_VALUE_IS_EXPANDABLE: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(16u32);
pub const DBGPROP_ATTRIB_VALUE_IS_FAKE: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(32u32);
pub const DBGPROP_ATTRIB_VALUE_IS_METHOD: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(256u32);
pub const DBGPROP_ATTRIB_VALUE_IS_EVENT: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(512u32);
pub const DBGPROP_ATTRIB_VALUE_IS_RAW_STRING: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(1024u32);
pub const DBGPROP_ATTRIB_VALUE_READONLY: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(2048u32);
pub const DBGPROP_ATTRIB_ACCESS_PUBLIC: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(4096u32);
pub const DBGPROP_ATTRIB_ACCESS_PRIVATE: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(8192u32);
pub const DBGPROP_ATTRIB_ACCESS_PROTECTED: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(16384u32);
pub const DBGPROP_ATTRIB_ACCESS_FINAL: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(32768u32);
pub const DBGPROP_ATTRIB_STORAGE_GLOBAL: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(65536u32);
pub const DBGPROP_ATTRIB_STORAGE_STATIC: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(131072u32);
pub const DBGPROP_ATTRIB_STORAGE_FIELD: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(262144u32);
pub const DBGPROP_ATTRIB_STORAGE_VIRTUAL: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(524288u32);
pub const DBGPROP_ATTRIB_TYPE_IS_CONSTANT: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(1048576u32);
pub const DBGPROP_ATTRIB_TYPE_IS_SYNCHRONIZED: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(2097152u32);
pub const DBGPROP_ATTRIB_TYPE_IS_VOLATILE: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(4194304u32);
pub const DBGPROP_ATTRIB_HAS_EXTENDED_ATTRIBS: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(8388608u32);
pub const DBGPROP_ATTRIB_FRAME_INTRYBLOCK: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(16777216u32);
pub const DBGPROP_ATTRIB_FRAME_INCATCHBLOCK: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(33554432u32);
pub const DBGPROP_ATTRIB_FRAME_INFINALLYBLOCK: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(67108864u32);
pub const DBGPROP_ATTRIB_VALUE_IS_RETURN_VALUE: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(134217728u32);
pub const DBGPROP_ATTRIB_VALUE_PENDING_MUTATION: DBGPROP_ATTRIB_FLAGS = DBGPROP_ATTRIB_FLAGS(268435456u32);
impl ::core::convert::From<u32> for DBGPROP_ATTRIB_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DBGPROP_ATTRIB_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for DBGPROP_ATTRIB_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for DBGPROP_ATTRIB_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for DBGPROP_ATTRIB_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for DBGPROP_ATTRIB_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for DBGPROP_ATTRIB_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DBGPROP_INFO(pub u32);
pub const DBGPROP_INFO_NAME: DBGPROP_INFO = DBGPROP_INFO(1u32);
pub const DBGPROP_INFO_TYPE: DBGPROP_INFO = DBGPROP_INFO(2u32);
pub const DBGPROP_INFO_VALUE: DBGPROP_INFO = DBGPROP_INFO(4u32);
pub const DBGPROP_INFO_FULLNAME: DBGPROP_INFO = DBGPROP_INFO(32u32);
pub const DBGPROP_INFO_ATTRIBUTES: DBGPROP_INFO = DBGPROP_INFO(8u32);
pub const DBGPROP_INFO_DEBUGPROP: DBGPROP_INFO = DBGPROP_INFO(16u32);
pub const DBGPROP_INFO_BEAUTIFY: DBGPROP_INFO = DBGPROP_INFO(33554432u32);
pub const DBGPROP_INFO_CALLTOSTRING: DBGPROP_INFO = DBGPROP_INFO(67108864u32);
pub const DBGPROP_INFO_AUTOEXPAND: DBGPROP_INFO = DBGPROP_INFO(134217728u32);
impl ::core::convert::From<u32> for DBGPROP_INFO {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DBGPROP_INFO {
type Abi = Self;
}
impl ::core::ops::BitOr for DBGPROP_INFO {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for DBGPROP_INFO {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for DBGPROP_INFO {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for DBGPROP_INFO {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for DBGPROP_INFO {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const DBG_DUMP_ADDRESS_AT_END: u32 = 131072u32;
pub const DBG_DUMP_ADDRESS_OF_FIELD: u32 = 65536u32;
pub const DBG_DUMP_ARRAY: u32 = 32768u32;
pub const DBG_DUMP_BLOCK_RECURSE: u32 = 2097152u32;
pub const DBG_DUMP_CALL_FOR_EACH: u32 = 8u32;
pub const DBG_DUMP_COMPACT_OUT: u32 = 8192u32;
pub const DBG_DUMP_COPY_TYPE_DATA: u32 = 262144u32;
pub const DBG_DUMP_FIELD_ARRAY: u32 = 16u32;
pub const DBG_DUMP_FIELD_CALL_BEFORE_PRINT: u32 = 1u32;
pub const DBG_DUMP_FIELD_COPY_FIELD_DATA: u32 = 32u32;
pub const DBG_DUMP_FIELD_DEFAULT_STRING: u32 = 65536u32;
pub const DBG_DUMP_FIELD_FULL_NAME: u32 = 8u32;
pub const DBG_DUMP_FIELD_GUID_STRING: u32 = 524288u32;
pub const DBG_DUMP_FIELD_MULTI_STRING: u32 = 262144u32;
pub const DBG_DUMP_FIELD_NO_CALLBACK_REQ: u32 = 2u32;
pub const DBG_DUMP_FIELD_NO_PRINT: u32 = 16384u32;
pub const DBG_DUMP_FIELD_RECUR_ON_THIS: u32 = 4u32;
pub const DBG_DUMP_FIELD_RETURN_ADDRESS: u32 = 4096u32;
pub const DBG_DUMP_FIELD_SIZE_IN_BITS: u32 = 8192u32;
pub const DBG_DUMP_FIELD_UTF32_STRING: u32 = 1048576u32;
pub const DBG_DUMP_FIELD_WCHAR_STRING: u32 = 131072u32;
pub const DBG_DUMP_FUNCTION_FORMAT: u32 = 1048576u32;
pub const DBG_DUMP_GET_SIZE_ONLY: u32 = 128u32;
pub const DBG_DUMP_LIST: u32 = 32u32;
pub const DBG_DUMP_MATCH_SIZE: u32 = 4194304u32;
pub const DBG_DUMP_NO_INDENT: u32 = 1u32;
pub const DBG_DUMP_NO_OFFSET: u32 = 2u32;
pub const DBG_DUMP_NO_PRINT: u32 = 64u32;
pub const DBG_DUMP_READ_PHYSICAL: u32 = 524288u32;
pub const DBG_DUMP_VERBOSE: u32 = 4u32;
pub const DBG_FRAME_DEFAULT: u32 = 0u32;
pub const DBG_FRAME_IGNORE_INLINE: u32 = 4294967295u32;
pub const DBG_RETURN_SUBTYPES: u32 = 0u32;
pub const DBG_RETURN_TYPE: u32 = 0u32;
pub const DBG_RETURN_TYPE_VALUES: u32 = 0u32;
pub const DBHHEADER_PDBGUID: u32 = 3u32;
pub const DEBUG_ADDSYNTHMOD_DEFAULT: u32 = 0u32;
pub const DEBUG_ADDSYNTHMOD_ZEROBASE: u32 = 1u32;
pub const DEBUG_ADDSYNTHSYM_DEFAULT: u32 = 0u32;
pub const DEBUG_ANY_ID: u32 = 4294967295u32;
pub const DEBUG_ASMOPT_DEFAULT: u32 = 0u32;
pub const DEBUG_ASMOPT_IGNORE_OUTPUT_WIDTH: u32 = 4u32;
pub const DEBUG_ASMOPT_NO_CODE_BYTES: u32 = 2u32;
pub const DEBUG_ASMOPT_SOURCE_LINE_NUMBER: u32 = 8u32;
pub const DEBUG_ASMOPT_VERBOSE: u32 = 1u32;
pub const DEBUG_ATTACH_DEFAULT: u32 = 0u32;
pub const DEBUG_ATTACH_EXDI_DRIVER: u32 = 2u32;
pub const DEBUG_ATTACH_EXISTING: u32 = 2u32;
pub const DEBUG_ATTACH_INSTALL_DRIVER: u32 = 4u32;
pub const DEBUG_ATTACH_INVASIVE_NO_INITIAL_BREAK: u32 = 8u32;
pub const DEBUG_ATTACH_INVASIVE_RESUME_PROCESS: u32 = 16u32;
pub const DEBUG_ATTACH_KERNEL_CONNECTION: u32 = 0u32;
pub const DEBUG_ATTACH_LOCAL_KERNEL: u32 = 1u32;
pub const DEBUG_ATTACH_NONINVASIVE: u32 = 1u32;
pub const DEBUG_ATTACH_NONINVASIVE_ALLOW_PARTIAL: u32 = 32u32;
pub const DEBUG_ATTACH_NONINVASIVE_NO_SUSPEND: u32 = 4u32;
pub const DEBUG_BREAKPOINT_ADDER_ONLY: u32 = 8u32;
pub const DEBUG_BREAKPOINT_CODE: u32 = 0u32;
pub const DEBUG_BREAKPOINT_DATA: u32 = 1u32;
pub const DEBUG_BREAKPOINT_DEFERRED: u32 = 2u32;
pub const DEBUG_BREAKPOINT_ENABLED: u32 = 4u32;
pub const DEBUG_BREAKPOINT_GO_ONLY: u32 = 1u32;
pub const DEBUG_BREAKPOINT_INLINE: u32 = 3u32;
pub const DEBUG_BREAKPOINT_ONE_SHOT: u32 = 16u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_BREAKPOINT_PARAMETERS {
pub Offset: u64,
pub Id: u32,
pub BreakType: u32,
pub ProcType: u32,
pub Flags: u32,
pub DataSize: u32,
pub DataAccessType: u32,
pub PassCount: u32,
pub CurrentPassCount: u32,
pub MatchThread: u32,
pub CommandSize: u32,
pub OffsetExpressionSize: u32,
}
impl DEBUG_BREAKPOINT_PARAMETERS {}
impl ::core::default::Default for DEBUG_BREAKPOINT_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_BREAKPOINT_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_BREAKPOINT_PARAMETERS")
.field("Offset", &self.Offset)
.field("Id", &self.Id)
.field("BreakType", &self.BreakType)
.field("ProcType", &self.ProcType)
.field("Flags", &self.Flags)
.field("DataSize", &self.DataSize)
.field("DataAccessType", &self.DataAccessType)
.field("PassCount", &self.PassCount)
.field("CurrentPassCount", &self.CurrentPassCount)
.field("MatchThread", &self.MatchThread)
.field("CommandSize", &self.CommandSize)
.field("OffsetExpressionSize", &self.OffsetExpressionSize)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_BREAKPOINT_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.Id == other.Id && self.BreakType == other.BreakType && self.ProcType == other.ProcType && self.Flags == other.Flags && self.DataSize == other.DataSize && self.DataAccessType == other.DataAccessType && self.PassCount == other.PassCount && self.CurrentPassCount == other.CurrentPassCount && self.MatchThread == other.MatchThread && self.CommandSize == other.CommandSize && self.OffsetExpressionSize == other.OffsetExpressionSize
}
}
impl ::core::cmp::Eq for DEBUG_BREAKPOINT_PARAMETERS {}
unsafe impl ::windows::core::Abi for DEBUG_BREAKPOINT_PARAMETERS {
type Abi = Self;
}
pub const DEBUG_BREAKPOINT_TIME: u32 = 2u32;
pub const DEBUG_BREAK_EXECUTE: u32 = 4u32;
pub const DEBUG_BREAK_IO: u32 = 8u32;
pub const DEBUG_BREAK_READ: u32 = 1u32;
pub const DEBUG_BREAK_WRITE: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_CACHED_SYMBOL_INFO {
pub ModBase: u64,
pub Arg1: u64,
pub Arg2: u64,
pub Id: u32,
pub Arg3: u32,
}
impl DEBUG_CACHED_SYMBOL_INFO {}
impl ::core::default::Default for DEBUG_CACHED_SYMBOL_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_CACHED_SYMBOL_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_CACHED_SYMBOL_INFO").field("ModBase", &self.ModBase).field("Arg1", &self.Arg1).field("Arg2", &self.Arg2).field("Id", &self.Id).field("Arg3", &self.Arg3).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_CACHED_SYMBOL_INFO {
fn eq(&self, other: &Self) -> bool {
self.ModBase == other.ModBase && self.Arg1 == other.Arg1 && self.Arg2 == other.Arg2 && self.Id == other.Id && self.Arg3 == other.Arg3
}
}
impl ::core::cmp::Eq for DEBUG_CACHED_SYMBOL_INFO {}
unsafe impl ::windows::core::Abi for DEBUG_CACHED_SYMBOL_INFO {
type Abi = Self;
}
pub const DEBUG_CDS_ALL: u32 = 4294967295u32;
pub const DEBUG_CDS_DATA: u32 = 2u32;
pub const DEBUG_CDS_REFRESH: u32 = 4u32;
pub const DEBUG_CDS_REFRESH_ADDBREAKPOINT: u32 = 4u32;
pub const DEBUG_CDS_REFRESH_EVALUATE: u32 = 1u32;
pub const DEBUG_CDS_REFRESH_EXECUTE: u32 = 2u32;
pub const DEBUG_CDS_REFRESH_EXECUTECOMMANDFILE: u32 = 3u32;
pub const DEBUG_CDS_REFRESH_INLINESTEP: u32 = 16u32;
pub const DEBUG_CDS_REFRESH_INLINESTEP_PSEUDO: u32 = 17u32;
pub const DEBUG_CDS_REFRESH_REMOVEBREAKPOINT: u32 = 5u32;
pub const DEBUG_CDS_REFRESH_SETSCOPE: u32 = 12u32;
pub const DEBUG_CDS_REFRESH_SETSCOPEFRAMEBYINDEX: u32 = 13u32;
pub const DEBUG_CDS_REFRESH_SETSCOPEFROMJITDEBUGINFO: u32 = 14u32;
pub const DEBUG_CDS_REFRESH_SETSCOPEFROMSTOREDEVENT: u32 = 15u32;
pub const DEBUG_CDS_REFRESH_SETVALUE: u32 = 10u32;
pub const DEBUG_CDS_REFRESH_SETVALUE2: u32 = 11u32;
pub const DEBUG_CDS_REFRESH_WRITEPHYSICAL: u32 = 8u32;
pub const DEBUG_CDS_REFRESH_WRITEPHYSICAL2: u32 = 9u32;
pub const DEBUG_CDS_REFRESH_WRITEVIRTUAL: u32 = 6u32;
pub const DEBUG_CDS_REFRESH_WRITEVIRTUALUNCACHED: u32 = 7u32;
pub const DEBUG_CDS_REGISTERS: u32 = 1u32;
pub const DEBUG_CES_ALL: u32 = 4294967295u32;
pub const DEBUG_CES_ASSEMBLY_OPTIONS: u32 = 4096u32;
pub const DEBUG_CES_BREAKPOINTS: u32 = 4u32;
pub const DEBUG_CES_CODE_LEVEL: u32 = 8u32;
pub const DEBUG_CES_CURRENT_THREAD: u32 = 1u32;
pub const DEBUG_CES_EFFECTIVE_PROCESSOR: u32 = 2u32;
pub const DEBUG_CES_ENGINE_OPTIONS: u32 = 32u32;
pub const DEBUG_CES_EVENT_FILTERS: u32 = 256u32;
pub const DEBUG_CES_EXECUTION_STATUS: u32 = 16u32;
pub const DEBUG_CES_EXPRESSION_SYNTAX: u32 = 8192u32;
pub const DEBUG_CES_EXTENSIONS: u32 = 1024u32;
pub const DEBUG_CES_LOG_FILE: u32 = 64u32;
pub const DEBUG_CES_PROCESS_OPTIONS: u32 = 512u32;
pub const DEBUG_CES_RADIX: u32 = 128u32;
pub const DEBUG_CES_SYSTEMS: u32 = 2048u32;
pub const DEBUG_CES_TEXT_REPLACEMENTS: u32 = 16384u32;
pub const DEBUG_CLASS_IMAGE_FILE: u32 = 3u32;
pub const DEBUG_CLASS_KERNEL: u32 = 1u32;
pub const DEBUG_CLASS_UNINITIALIZED: u32 = 0u32;
pub const DEBUG_CLASS_USER_WINDOWS: u32 = 2u32;
pub const DEBUG_CLIENT_CDB: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_CLIENT_CONTEXT {
pub cbSize: u32,
pub eClient: u32,
}
impl DEBUG_CLIENT_CONTEXT {}
impl ::core::default::Default for DEBUG_CLIENT_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_CLIENT_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_CLIENT_CONTEXT").field("cbSize", &self.cbSize).field("eClient", &self.eClient).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_CLIENT_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.cbSize == other.cbSize && self.eClient == other.eClient
}
}
impl ::core::cmp::Eq for DEBUG_CLIENT_CONTEXT {}
unsafe impl ::windows::core::Abi for DEBUG_CLIENT_CONTEXT {
type Abi = Self;
}
pub const DEBUG_CLIENT_KD: u32 = 5u32;
pub const DEBUG_CLIENT_NTKD: u32 = 3u32;
pub const DEBUG_CLIENT_NTSD: u32 = 2u32;
pub const DEBUG_CLIENT_UNKNOWN: u32 = 0u32;
pub const DEBUG_CLIENT_VSINT: u32 = 1u32;
pub const DEBUG_CLIENT_WINDBG: u32 = 6u32;
pub const DEBUG_CLIENT_WINIDE: u32 = 7u32;
pub const DEBUG_CMDEX_ADD_EVENT_STRING: u32 = 1u32;
pub const DEBUG_CMDEX_INVALID: u32 = 0u32;
pub const DEBUG_CMDEX_RESET_EVENT_STRINGS: u32 = 2u32;
pub const DEBUG_COMMAND_EXCEPTION_ID: u32 = 3688893886u32;
pub const DEBUG_CONNECT_SESSION_DEFAULT: u32 = 0u32;
pub const DEBUG_CONNECT_SESSION_NO_ANNOUNCE: u32 = 2u32;
pub const DEBUG_CONNECT_SESSION_NO_VERSION: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_CREATE_PROCESS_OPTIONS {
pub CreateFlags: u32,
pub EngCreateFlags: u32,
pub VerifierFlags: u32,
pub Reserved: u32,
}
impl DEBUG_CREATE_PROCESS_OPTIONS {}
impl ::core::default::Default for DEBUG_CREATE_PROCESS_OPTIONS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_CREATE_PROCESS_OPTIONS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_CREATE_PROCESS_OPTIONS").field("CreateFlags", &self.CreateFlags).field("EngCreateFlags", &self.EngCreateFlags).field("VerifierFlags", &self.VerifierFlags).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_CREATE_PROCESS_OPTIONS {
fn eq(&self, other: &Self) -> bool {
self.CreateFlags == other.CreateFlags && self.EngCreateFlags == other.EngCreateFlags && self.VerifierFlags == other.VerifierFlags && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_CREATE_PROCESS_OPTIONS {}
unsafe impl ::windows::core::Abi for DEBUG_CREATE_PROCESS_OPTIONS {
type Abi = Self;
}
pub const DEBUG_CSS_ALL: u32 = 4294967295u32;
pub const DEBUG_CSS_COLLAPSE_CHILDREN: u32 = 64u32;
pub const DEBUG_CSS_LOADS: u32 = 1u32;
pub const DEBUG_CSS_PATHS: u32 = 8u32;
pub const DEBUG_CSS_SCOPE: u32 = 4u32;
pub const DEBUG_CSS_SYMBOL_OPTIONS: u32 = 16u32;
pub const DEBUG_CSS_TYPE_OPTIONS: u32 = 32u32;
pub const DEBUG_CSS_UNLOADS: u32 = 2u32;
pub const DEBUG_CURRENT_DEFAULT: u32 = 15u32;
pub const DEBUG_CURRENT_DISASM: u32 = 2u32;
pub const DEBUG_CURRENT_REGISTERS: u32 = 4u32;
pub const DEBUG_CURRENT_SOURCE_LINE: u32 = 8u32;
pub const DEBUG_CURRENT_SYMBOL: u32 = 1u32;
pub const DEBUG_DATA_BASE_TRANSLATION_VIRTUAL_OFFSET: u32 = 3u32;
pub const DEBUG_DATA_BreakpointWithStatusAddr: u32 = 32u32;
pub const DEBUG_DATA_CmNtCSDVersionAddr: u32 = 616u32;
pub const DEBUG_DATA_DumpAttributes: u32 = 100072u32;
pub const DEBUG_DATA_DumpFormatVersion: u32 = 100040u32;
pub const DEBUG_DATA_DumpMmStorage: u32 = 100064u32;
pub const DEBUG_DATA_DumpPowerState: u32 = 100056u32;
pub const DEBUG_DATA_DumpWriterStatus: u32 = 100032u32;
pub const DEBUG_DATA_DumpWriterVersion: u32 = 100048u32;
pub const DEBUG_DATA_EtwpDebuggerData: u32 = 816u32;
pub const DEBUG_DATA_ExpNumberOfPagedPoolsAddr: u32 = 112u32;
pub const DEBUG_DATA_ExpPagedPoolDescriptorAddr: u32 = 104u32;
pub const DEBUG_DATA_ExpSystemResourcesListAddr: u32 = 96u32;
pub const DEBUG_DATA_IopErrorLogListHeadAddr: u32 = 144u32;
pub const DEBUG_DATA_KPCR_OFFSET: u32 = 0u32;
pub const DEBUG_DATA_KPRCB_OFFSET: u32 = 1u32;
pub const DEBUG_DATA_KTHREAD_OFFSET: u32 = 2u32;
pub const DEBUG_DATA_KdPrintBufferSizeAddr: u32 = 720u32;
pub const DEBUG_DATA_KdPrintCircularBufferAddr: u32 = 480u32;
pub const DEBUG_DATA_KdPrintCircularBufferEndAddr: u32 = 488u32;
pub const DEBUG_DATA_KdPrintCircularBufferPtrAddr: u32 = 712u32;
pub const DEBUG_DATA_KdPrintRolloverCountAddr: u32 = 504u32;
pub const DEBUG_DATA_KdPrintWritePointerAddr: u32 = 496u32;
pub const DEBUG_DATA_KeBugCheckCallbackListHeadAddr: u32 = 128u32;
pub const DEBUG_DATA_KeTimeIncrementAddr: u32 = 120u32;
pub const DEBUG_DATA_KeUserCallbackDispatcherAddr: u32 = 64u32;
pub const DEBUG_DATA_KernBase: u32 = 24u32;
pub const DEBUG_DATA_KernelVerifierAddr: u32 = 576u32;
pub const DEBUG_DATA_KiBugcheckDataAddr: u32 = 136u32;
pub const DEBUG_DATA_KiCallUserModeAddr: u32 = 56u32;
pub const DEBUG_DATA_KiNormalSystemCall: u32 = 528u32;
pub const DEBUG_DATA_KiProcessorBlockAddr: u32 = 536u32;
pub const DEBUG_DATA_MmAllocatedNonPagedPoolAddr: u32 = 592u32;
pub const DEBUG_DATA_MmAvailablePagesAddr: u32 = 424u32;
pub const DEBUG_DATA_MmBadPagesDetected: u32 = 800u32;
pub const DEBUG_DATA_MmDriverCommitAddr: u32 = 352u32;
pub const DEBUG_DATA_MmExtendedCommitAddr: u32 = 376u32;
pub const DEBUG_DATA_MmFreePageListHeadAddr: u32 = 392u32;
pub const DEBUG_DATA_MmHighestPhysicalPageAddr: u32 = 240u32;
pub const DEBUG_DATA_MmHighestUserAddressAddr: u32 = 456u32;
pub const DEBUG_DATA_MmLastUnloadedDriverAddr: u32 = 552u32;
pub const DEBUG_DATA_MmLoadedUserImageListAddr: u32 = 512u32;
pub const DEBUG_DATA_MmLowestPhysicalPageAddr: u32 = 232u32;
pub const DEBUG_DATA_MmMaximumNonPagedPoolInBytesAddr: u32 = 256u32;
pub const DEBUG_DATA_MmModifiedNoWritePageListHeadAddr: u32 = 416u32;
pub const DEBUG_DATA_MmModifiedPageListHeadAddr: u32 = 408u32;
pub const DEBUG_DATA_MmNonPagedPoolEndAddr: u32 = 280u32;
pub const DEBUG_DATA_MmNonPagedPoolStartAddr: u32 = 272u32;
pub const DEBUG_DATA_MmNonPagedSystemStartAddr: u32 = 264u32;
pub const DEBUG_DATA_MmNumberOfPagingFilesAddr: u32 = 224u32;
pub const DEBUG_DATA_MmNumberOfPhysicalPagesAddr: u32 = 248u32;
pub const DEBUG_DATA_MmPageSize: u32 = 312u32;
pub const DEBUG_DATA_MmPagedPoolCommitAddr: u32 = 368u32;
pub const DEBUG_DATA_MmPagedPoolEndAddr: u32 = 296u32;
pub const DEBUG_DATA_MmPagedPoolInformationAddr: u32 = 304u32;
pub const DEBUG_DATA_MmPagedPoolStartAddr: u32 = 288u32;
pub const DEBUG_DATA_MmPeakCommitmentAddr: u32 = 600u32;
pub const DEBUG_DATA_MmPfnDatabaseAddr: u32 = 192u32;
pub const DEBUG_DATA_MmPhysicalMemoryBlockAddr: u32 = 624u32;
pub const DEBUG_DATA_MmProcessCommitAddr: u32 = 360u32;
pub const DEBUG_DATA_MmResidentAvailablePagesAddr: u32 = 432u32;
pub const DEBUG_DATA_MmSessionBase: u32 = 632u32;
pub const DEBUG_DATA_MmSessionSize: u32 = 640u32;
pub const DEBUG_DATA_MmSharedCommitAddr: u32 = 344u32;
pub const DEBUG_DATA_MmSizeOfPagedPoolInBytesAddr: u32 = 320u32;
pub const DEBUG_DATA_MmSpecialPoolTagAddr: u32 = 568u32;
pub const DEBUG_DATA_MmStandbyPageListHeadAddr: u32 = 400u32;
pub const DEBUG_DATA_MmSubsectionBaseAddr: u32 = 216u32;
pub const DEBUG_DATA_MmSystemCacheEndAddr: u32 = 176u32;
pub const DEBUG_DATA_MmSystemCacheStartAddr: u32 = 168u32;
pub const DEBUG_DATA_MmSystemCacheWsAddr: u32 = 184u32;
pub const DEBUG_DATA_MmSystemParentTablePage: u32 = 648u32;
pub const DEBUG_DATA_MmSystemPtesEndAddr: u32 = 208u32;
pub const DEBUG_DATA_MmSystemPtesStartAddr: u32 = 200u32;
pub const DEBUG_DATA_MmSystemRangeStartAddr: u32 = 464u32;
pub const DEBUG_DATA_MmTotalCommitLimitAddr: u32 = 328u32;
pub const DEBUG_DATA_MmTotalCommitLimitMaximumAddr: u32 = 608u32;
pub const DEBUG_DATA_MmTotalCommittedPagesAddr: u32 = 336u32;
pub const DEBUG_DATA_MmTriageActionTakenAddr: u32 = 560u32;
pub const DEBUG_DATA_MmUnloadedDriversAddr: u32 = 544u32;
pub const DEBUG_DATA_MmUserProbeAddressAddr: u32 = 472u32;
pub const DEBUG_DATA_MmVerifierDataAddr: u32 = 584u32;
pub const DEBUG_DATA_MmVirtualTranslationBase: u32 = 656u32;
pub const DEBUG_DATA_MmZeroedPageListHeadAddr: u32 = 384u32;
pub const DEBUG_DATA_NonPagedPoolDescriptorAddr: u32 = 448u32;
pub const DEBUG_DATA_NtBuildLabAddr: u32 = 520u32;
pub const DEBUG_DATA_ObpRootDirectoryObjectAddr: u32 = 152u32;
pub const DEBUG_DATA_ObpTypeObjectTypeAddr: u32 = 160u32;
pub const DEBUG_DATA_OffsetEprocessDirectoryTableBase: u32 = 686u32;
pub const DEBUG_DATA_OffsetEprocessParentCID: u32 = 684u32;
pub const DEBUG_DATA_OffsetEprocessPeb: u32 = 682u32;
pub const DEBUG_DATA_OffsetKThreadApcProcess: u32 = 672u32;
pub const DEBUG_DATA_OffsetKThreadBStore: u32 = 676u32;
pub const DEBUG_DATA_OffsetKThreadBStoreLimit: u32 = 678u32;
pub const DEBUG_DATA_OffsetKThreadInitialStack: u32 = 670u32;
pub const DEBUG_DATA_OffsetKThreadKernelStack: u32 = 668u32;
pub const DEBUG_DATA_OffsetKThreadNextProcessor: u32 = 664u32;
pub const DEBUG_DATA_OffsetKThreadState: u32 = 674u32;
pub const DEBUG_DATA_OffsetKThreadTeb: u32 = 666u32;
pub const DEBUG_DATA_OffsetPrcbCpuType: u32 = 696u32;
pub const DEBUG_DATA_OffsetPrcbCurrentThread: u32 = 692u32;
pub const DEBUG_DATA_OffsetPrcbDpcRoutine: u32 = 690u32;
pub const DEBUG_DATA_OffsetPrcbMhz: u32 = 694u32;
pub const DEBUG_DATA_OffsetPrcbNumber: u32 = 702u32;
pub const DEBUG_DATA_OffsetPrcbProcessorState: u32 = 700u32;
pub const DEBUG_DATA_OffsetPrcbVendorString: u32 = 698u32;
pub const DEBUG_DATA_PROCESSOR_IDENTIFICATION: u32 = 4u32;
pub const DEBUG_DATA_PROCESSOR_SPEED: u32 = 5u32;
pub const DEBUG_DATA_PaeEnabled: u32 = 100000u32;
pub const DEBUG_DATA_PoolTrackTableAddr: u32 = 440u32;
pub const DEBUG_DATA_ProductType: u32 = 100016u32;
pub const DEBUG_DATA_PsActiveProcessHeadAddr: u32 = 80u32;
pub const DEBUG_DATA_PsLoadedModuleListAddr: u32 = 72u32;
pub const DEBUG_DATA_PspCidTableAddr: u32 = 88u32;
pub const DEBUG_DATA_PteBase: u32 = 864u32;
pub const DEBUG_DATA_SPACE_BUS_DATA: u32 = 5u32;
pub const DEBUG_DATA_SPACE_CONTROL: u32 = 2u32;
pub const DEBUG_DATA_SPACE_COUNT: u32 = 7u32;
pub const DEBUG_DATA_SPACE_DEBUGGER_DATA: u32 = 6u32;
pub const DEBUG_DATA_SPACE_IO: u32 = 3u32;
pub const DEBUG_DATA_SPACE_MSR: u32 = 4u32;
pub const DEBUG_DATA_SPACE_PHYSICAL: u32 = 1u32;
pub const DEBUG_DATA_SPACE_VIRTUAL: u32 = 0u32;
pub const DEBUG_DATA_SavedContextAddr: u32 = 40u32;
pub const DEBUG_DATA_SharedUserData: u32 = 100008u32;
pub const DEBUG_DATA_SizeEProcess: u32 = 680u32;
pub const DEBUG_DATA_SizeEThread: u32 = 704u32;
pub const DEBUG_DATA_SizePrcb: u32 = 688u32;
pub const DEBUG_DATA_SuiteMask: u32 = 100024u32;
pub const DEBUG_DISASM_EFFECTIVE_ADDRESS: u32 = 1u32;
pub const DEBUG_DISASM_MATCHING_SYMBOLS: u32 = 2u32;
pub const DEBUG_DISASM_SOURCE_FILE_NAME: u32 = 8u32;
pub const DEBUG_DISASM_SOURCE_LINE_NUMBER: u32 = 4u32;
pub const DEBUG_DUMP_ACTIVE: u32 = 1030u32;
pub const DEBUG_DUMP_DEFAULT: u32 = 1025u32;
pub const DEBUG_DUMP_FILE_BASE: u32 = 4294967295u32;
pub const DEBUG_DUMP_FILE_LOAD_FAILED_INDEX: u32 = 4294967295u32;
pub const DEBUG_DUMP_FILE_ORIGINAL_CAB_INDEX: u32 = 4294967294u32;
pub const DEBUG_DUMP_FILE_PAGE_FILE_DUMP: u32 = 0u32;
pub const DEBUG_DUMP_FULL: u32 = 1026u32;
pub const DEBUG_DUMP_IMAGE_FILE: u32 = 1027u32;
pub const DEBUG_DUMP_SMALL: u32 = 1024u32;
pub const DEBUG_DUMP_TRACE_LOG: u32 = 1028u32;
pub const DEBUG_DUMP_WINDOWS_CE: u32 = 1029u32;
pub const DEBUG_ECREATE_PROCESS_DEFAULT: u32 = 0u32;
pub const DEBUG_ECREATE_PROCESS_INHERIT_HANDLES: u32 = 1u32;
pub const DEBUG_ECREATE_PROCESS_USE_IMPLICIT_COMMAND_LINE: u32 = 4u32;
pub const DEBUG_ECREATE_PROCESS_USE_VERIFIER_FLAGS: u32 = 2u32;
pub const DEBUG_EINDEX_FROM_CURRENT: u32 = 2u32;
pub const DEBUG_EINDEX_FROM_END: u32 = 1u32;
pub const DEBUG_EINDEX_FROM_START: u32 = 0u32;
pub const DEBUG_EINDEX_NAME: u32 = 0u32;
pub const DEBUG_END_ACTIVE_DETACH: u32 = 2u32;
pub const DEBUG_END_ACTIVE_TERMINATE: u32 = 1u32;
pub const DEBUG_END_DISCONNECT: u32 = 4u32;
pub const DEBUG_END_PASSIVE: u32 = 0u32;
pub const DEBUG_END_REENTRANT: u32 = 3u32;
pub const DEBUG_ENGOPT_ALL: u32 = 15728639u32;
pub const DEBUG_ENGOPT_ALLOW_NETWORK_PATHS: u32 = 4u32;
pub const DEBUG_ENGOPT_ALLOW_READ_ONLY_BREAKPOINTS: u32 = 1024u32;
pub const DEBUG_ENGOPT_DEBUGGING_SENSITIVE_DATA: u32 = 4194304u32;
pub const DEBUG_ENGOPT_DISABLESQM: u32 = 524288u32;
pub const DEBUG_ENGOPT_DISABLE_EXECUTION_COMMANDS: u32 = 65536u32;
pub const DEBUG_ENGOPT_DISABLE_MANAGED_SUPPORT: u32 = 16384u32;
pub const DEBUG_ENGOPT_DISABLE_MODULE_SYMBOL_LOAD: u32 = 32768u32;
pub const DEBUG_ENGOPT_DISABLE_STEPLINES_OPTIONS: u32 = 2097152u32;
pub const DEBUG_ENGOPT_DISALLOW_IMAGE_FILE_MAPPING: u32 = 131072u32;
pub const DEBUG_ENGOPT_DISALLOW_NETWORK_PATHS: u32 = 8u32;
pub const DEBUG_ENGOPT_DISALLOW_SHELL_COMMANDS: u32 = 4096u32;
pub const DEBUG_ENGOPT_FAIL_INCOMPLETE_INFORMATION: u32 = 512u32;
pub const DEBUG_ENGOPT_FINAL_BREAK: u32 = 128u32;
pub const DEBUG_ENGOPT_IGNORE_DBGHELP_VERSION: u32 = 1u32;
pub const DEBUG_ENGOPT_IGNORE_EXTENSION_VERSIONS: u32 = 2u32;
pub const DEBUG_ENGOPT_IGNORE_LOADER_EXCEPTIONS: u32 = 16u32;
pub const DEBUG_ENGOPT_INITIAL_BREAK: u32 = 32u32;
pub const DEBUG_ENGOPT_INITIAL_MODULE_BREAK: u32 = 64u32;
pub const DEBUG_ENGOPT_KD_QUIET_MODE: u32 = 8192u32;
pub const DEBUG_ENGOPT_NO_EXECUTE_REPEAT: u32 = 256u32;
pub const DEBUG_ENGOPT_PREFER_DML: u32 = 262144u32;
pub const DEBUG_ENGOPT_PREFER_TRACE_FILES: u32 = 8388608u32;
pub const DEBUG_ENGOPT_SYNCHRONIZE_BREAKPOINTS: u32 = 2048u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::clone::Clone for DEBUG_EVENT {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
pub struct DEBUG_EVENT {
pub dwDebugEventCode: DEBUG_EVENT_CODE,
pub dwProcessId: u32,
pub dwThreadId: u32,
pub u: DEBUG_EVENT_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl DEBUG_EVENT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::default::Default for DEBUG_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::PartialEq for DEBUG_EVENT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::Eq for DEBUG_EVENT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
unsafe impl ::windows::core::Abi for DEBUG_EVENT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::clone::Clone for DEBUG_EVENT_0 {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
pub union DEBUG_EVENT_0 {
pub Exception: EXCEPTION_DEBUG_INFO,
pub CreateThread: ::core::mem::ManuallyDrop<CREATE_THREAD_DEBUG_INFO>,
pub CreateProcessInfo: ::core::mem::ManuallyDrop<CREATE_PROCESS_DEBUG_INFO>,
pub ExitThread: EXIT_THREAD_DEBUG_INFO,
pub ExitProcess: EXIT_PROCESS_DEBUG_INFO,
pub LoadDll: LOAD_DLL_DEBUG_INFO,
pub UnloadDll: UNLOAD_DLL_DEBUG_INFO,
pub DebugString: OUTPUT_DEBUG_STRING_INFO,
pub RipInfo: RIP_INFO,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl DEBUG_EVENT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::default::Default for DEBUG_EVENT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::PartialEq for DEBUG_EVENT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
impl ::core::cmp::Eq for DEBUG_EVENT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
unsafe impl ::windows::core::Abi for DEBUG_EVENT_0 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const DEBUG_EVENT_BREAKPOINT: u32 = 1u32;
pub const DEBUG_EVENT_CHANGE_DEBUGGEE_STATE: u32 = 1024u32;
pub const DEBUG_EVENT_CHANGE_ENGINE_STATE: u32 = 2048u32;
pub const DEBUG_EVENT_CHANGE_SYMBOL_STATE: u32 = 4096u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEBUG_EVENT_CODE(pub u32);
pub const CREATE_PROCESS_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(3u32);
pub const CREATE_THREAD_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(2u32);
pub const EXCEPTION_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(1u32);
pub const EXIT_PROCESS_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(5u32);
pub const EXIT_THREAD_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(4u32);
pub const LOAD_DLL_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(6u32);
pub const OUTPUT_DEBUG_STRING_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(8u32);
pub const RIP_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(9u32);
pub const UNLOAD_DLL_DEBUG_EVENT: DEBUG_EVENT_CODE = DEBUG_EVENT_CODE(7u32);
impl ::core::convert::From<u32> for DEBUG_EVENT_CODE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEBUG_EVENT_CODE {
type Abi = Self;
}
impl ::core::ops::BitOr for DEBUG_EVENT_CODE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for DEBUG_EVENT_CODE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for DEBUG_EVENT_CODE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for DEBUG_EVENT_CODE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for DEBUG_EVENT_CODE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_EVENT_CONTEXT {
pub Size: u32,
pub ProcessEngineId: u32,
pub ThreadEngineId: u32,
pub FrameEngineId: u32,
}
impl DEBUG_EVENT_CONTEXT {}
impl ::core::default::Default for DEBUG_EVENT_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_EVENT_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_EVENT_CONTEXT").field("Size", &self.Size).field("ProcessEngineId", &self.ProcessEngineId).field("ThreadEngineId", &self.ThreadEngineId).field("FrameEngineId", &self.FrameEngineId).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_EVENT_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size && self.ProcessEngineId == other.ProcessEngineId && self.ThreadEngineId == other.ThreadEngineId && self.FrameEngineId == other.FrameEngineId
}
}
impl ::core::cmp::Eq for DEBUG_EVENT_CONTEXT {}
unsafe impl ::windows::core::Abi for DEBUG_EVENT_CONTEXT {
type Abi = Self;
}
pub const DEBUG_EVENT_CREATE_PROCESS: u32 = 16u32;
pub const DEBUG_EVENT_CREATE_THREAD: u32 = 4u32;
pub const DEBUG_EVENT_EXCEPTION: u32 = 2u32;
pub const DEBUG_EVENT_EXIT_PROCESS: u32 = 32u32;
pub const DEBUG_EVENT_EXIT_THREAD: u32 = 8u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEBUG_EVENT_INFO_TYPE(pub i32);
pub const DEIT_GENERAL: DEBUG_EVENT_INFO_TYPE = DEBUG_EVENT_INFO_TYPE(0i32);
pub const DEIT_ASMJS_IN_DEBUGGING: DEBUG_EVENT_INFO_TYPE = DEBUG_EVENT_INFO_TYPE(1i32);
pub const DEIT_ASMJS_SUCCEEDED: DEBUG_EVENT_INFO_TYPE = DEBUG_EVENT_INFO_TYPE(2i32);
pub const DEIT_ASMJS_FAILED: DEBUG_EVENT_INFO_TYPE = DEBUG_EVENT_INFO_TYPE(3i32);
impl ::core::convert::From<i32> for DEBUG_EVENT_INFO_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEBUG_EVENT_INFO_TYPE {
type Abi = Self;
}
pub const DEBUG_EVENT_LOAD_MODULE: u32 = 64u32;
pub const DEBUG_EVENT_SERVICE_EXCEPTION: u32 = 8192u32;
pub const DEBUG_EVENT_SESSION_STATUS: u32 = 512u32;
pub const DEBUG_EVENT_SYSTEM_ERROR: u32 = 256u32;
pub const DEBUG_EVENT_UNLOAD_MODULE: u32 = 128u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_EXCEPTION_FILTER_PARAMETERS {
pub ExecutionOption: u32,
pub ContinueOption: u32,
pub TextSize: u32,
pub CommandSize: u32,
pub SecondCommandSize: u32,
pub ExceptionCode: u32,
}
impl DEBUG_EXCEPTION_FILTER_PARAMETERS {}
impl ::core::default::Default for DEBUG_EXCEPTION_FILTER_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_EXCEPTION_FILTER_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_EXCEPTION_FILTER_PARAMETERS")
.field("ExecutionOption", &self.ExecutionOption)
.field("ContinueOption", &self.ContinueOption)
.field("TextSize", &self.TextSize)
.field("CommandSize", &self.CommandSize)
.field("SecondCommandSize", &self.SecondCommandSize)
.field("ExceptionCode", &self.ExceptionCode)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_EXCEPTION_FILTER_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.ExecutionOption == other.ExecutionOption && self.ContinueOption == other.ContinueOption && self.TextSize == other.TextSize && self.CommandSize == other.CommandSize && self.SecondCommandSize == other.SecondCommandSize && self.ExceptionCode == other.ExceptionCode
}
}
impl ::core::cmp::Eq for DEBUG_EXCEPTION_FILTER_PARAMETERS {}
unsafe impl ::windows::core::Abi for DEBUG_EXCEPTION_FILTER_PARAMETERS {
type Abi = Self;
}
pub const DEBUG_EXECUTE_DEFAULT: u32 = 0u32;
pub const DEBUG_EXECUTE_ECHO: u32 = 1u32;
pub const DEBUG_EXECUTE_EVENT: u32 = 2048u32;
pub const DEBUG_EXECUTE_EXTENSION: u32 = 32u32;
pub const DEBUG_EXECUTE_HOTKEY: u32 = 1024u32;
pub const DEBUG_EXECUTE_INTERNAL: u32 = 64u32;
pub const DEBUG_EXECUTE_MENU: u32 = 512u32;
pub const DEBUG_EXECUTE_NOT_LOGGED: u32 = 2u32;
pub const DEBUG_EXECUTE_NO_REPEAT: u32 = 4u32;
pub const DEBUG_EXECUTE_SCRIPT: u32 = 128u32;
pub const DEBUG_EXECUTE_TOOLBAR: u32 = 256u32;
pub const DEBUG_EXECUTE_USER_CLICKED: u32 = 16u32;
pub const DEBUG_EXECUTE_USER_TYPED: u32 = 8u32;
pub const DEBUG_EXEC_FLAGS_NONBLOCK: u32 = 1u32;
pub const DEBUG_EXPR_CPLUSPLUS: u32 = 1u32;
pub const DEBUG_EXPR_MASM: u32 = 0u32;
pub const DEBUG_EXTENSION_AT_ENGINE: u32 = 0u32;
pub const DEBUG_EXTINIT_HAS_COMMAND_HELP: u32 = 1u32;
pub const DEBUG_EXT_PVALUE_DEFAULT: u32 = 0u32;
pub const DEBUG_EXT_PVTYPE_IS_POINTER: u32 = 1u32;
pub const DEBUG_EXT_PVTYPE_IS_VALUE: u32 = 0u32;
pub const DEBUG_EXT_QVALUE_DEFAULT: u32 = 0u32;
pub const DEBUG_FILTER_BREAK: u32 = 0u32;
pub const DEBUG_FILTER_CREATE_PROCESS: u32 = 2u32;
pub const DEBUG_FILTER_CREATE_THREAD: u32 = 0u32;
pub const DEBUG_FILTER_DEBUGGEE_OUTPUT: u32 = 9u32;
pub const DEBUG_FILTER_EXIT_PROCESS: u32 = 3u32;
pub const DEBUG_FILTER_EXIT_THREAD: u32 = 1u32;
pub const DEBUG_FILTER_GO_HANDLED: u32 = 0u32;
pub const DEBUG_FILTER_GO_NOT_HANDLED: u32 = 1u32;
pub const DEBUG_FILTER_IGNORE: u32 = 3u32;
pub const DEBUG_FILTER_INITIAL_BREAKPOINT: u32 = 7u32;
pub const DEBUG_FILTER_INITIAL_MODULE_LOAD: u32 = 8u32;
pub const DEBUG_FILTER_LOAD_MODULE: u32 = 4u32;
pub const DEBUG_FILTER_OUTPUT: u32 = 2u32;
pub const DEBUG_FILTER_REMOVE: u32 = 4u32;
pub const DEBUG_FILTER_SECOND_CHANCE_BREAK: u32 = 1u32;
pub const DEBUG_FILTER_SYSTEM_ERROR: u32 = 6u32;
pub const DEBUG_FILTER_UNLOAD_MODULE: u32 = 5u32;
pub const DEBUG_FIND_SOURCE_BEST_MATCH: u32 = 2u32;
pub const DEBUG_FIND_SOURCE_DEFAULT: u32 = 0u32;
pub const DEBUG_FIND_SOURCE_FULL_PATH: u32 = 1u32;
pub const DEBUG_FIND_SOURCE_NO_SRCSRV: u32 = 4u32;
pub const DEBUG_FIND_SOURCE_TOKEN_LOOKUP: u32 = 8u32;
pub const DEBUG_FIND_SOURCE_WITH_CHECKSUM: u32 = 16u32;
pub const DEBUG_FIND_SOURCE_WITH_CHECKSUM_STRICT: u32 = 32u32;
pub const DEBUG_FORMAT_CAB_SECONDARY_ALL_IMAGES: u32 = 268435456u32;
pub const DEBUG_FORMAT_CAB_SECONDARY_FILES: u32 = 1073741824u32;
pub const DEBUG_FORMAT_DEFAULT: u32 = 0u32;
pub const DEBUG_FORMAT_NO_OVERWRITE: u32 = 2147483648u32;
pub const DEBUG_FORMAT_USER_SMALL_ADD_AVX_XSTATE_CONTEXT: u32 = 131072u32;
pub const DEBUG_FORMAT_USER_SMALL_CODE_SEGMENTS: u32 = 4096u32;
pub const DEBUG_FORMAT_USER_SMALL_DATA_SEGMENTS: u32 = 16u32;
pub const DEBUG_FORMAT_USER_SMALL_FILTER_MEMORY: u32 = 32u32;
pub const DEBUG_FORMAT_USER_SMALL_FILTER_PATHS: u32 = 64u32;
pub const DEBUG_FORMAT_USER_SMALL_FILTER_TRIAGE: u32 = 65536u32;
pub const DEBUG_FORMAT_USER_SMALL_FULL_AUXILIARY_STATE: u32 = 16384u32;
pub const DEBUG_FORMAT_USER_SMALL_FULL_MEMORY: u32 = 1u32;
pub const DEBUG_FORMAT_USER_SMALL_FULL_MEMORY_INFO: u32 = 1024u32;
pub const DEBUG_FORMAT_USER_SMALL_HANDLE_DATA: u32 = 2u32;
pub const DEBUG_FORMAT_USER_SMALL_IGNORE_INACCESSIBLE_MEM: u32 = 134217728u32;
pub const DEBUG_FORMAT_USER_SMALL_INDIRECT_MEMORY: u32 = 8u32;
pub const DEBUG_FORMAT_USER_SMALL_IPT_TRACE: u32 = 262144u32;
pub const DEBUG_FORMAT_USER_SMALL_MODULE_HEADERS: u32 = 32768u32;
pub const DEBUG_FORMAT_USER_SMALL_NO_AUXILIARY_STATE: u32 = 8192u32;
pub const DEBUG_FORMAT_USER_SMALL_NO_OPTIONAL_DATA: u32 = 512u32;
pub const DEBUG_FORMAT_USER_SMALL_PRIVATE_READ_WRITE_MEMORY: u32 = 256u32;
pub const DEBUG_FORMAT_USER_SMALL_PROCESS_THREAD_DATA: u32 = 128u32;
pub const DEBUG_FORMAT_USER_SMALL_SCAN_PARTIAL_PAGES: u32 = 268435456u32;
pub const DEBUG_FORMAT_USER_SMALL_THREAD_INFO: u32 = 2048u32;
pub const DEBUG_FORMAT_USER_SMALL_UNLOADED_MODULES: u32 = 4u32;
pub const DEBUG_FORMAT_WRITE_CAB: u32 = 536870912u32;
pub const DEBUG_FRAME_DEFAULT: u32 = 0u32;
pub const DEBUG_FRAME_IGNORE_INLINE: u32 = 1u32;
pub const DEBUG_GETFNENT_DEFAULT: u32 = 0u32;
pub const DEBUG_GETFNENT_RAW_ENTRY_ONLY: u32 = 1u32;
pub const DEBUG_GETMOD_DEFAULT: u32 = 0u32;
pub const DEBUG_GETMOD_NO_LOADED_MODULES: u32 = 1u32;
pub const DEBUG_GETMOD_NO_UNLOADED_MODULES: u32 = 2u32;
pub const DEBUG_GET_PROC_DEFAULT: u32 = 0u32;
pub const DEBUG_GET_PROC_FULL_MATCH: u32 = 1u32;
pub const DEBUG_GET_PROC_ONLY_MATCH: u32 = 2u32;
pub const DEBUG_GET_PROC_SERVICE_NAME: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_GET_TEXT_COMPLETIONS_IN {
pub Flags: u32,
pub MatchCountLimit: u32,
pub Reserved: [u64; 3],
}
impl DEBUG_GET_TEXT_COMPLETIONS_IN {}
impl ::core::default::Default for DEBUG_GET_TEXT_COMPLETIONS_IN {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_GET_TEXT_COMPLETIONS_IN {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_GET_TEXT_COMPLETIONS_IN").field("Flags", &self.Flags).field("MatchCountLimit", &self.MatchCountLimit).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_GET_TEXT_COMPLETIONS_IN {
fn eq(&self, other: &Self) -> bool {
self.Flags == other.Flags && self.MatchCountLimit == other.MatchCountLimit && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_GET_TEXT_COMPLETIONS_IN {}
unsafe impl ::windows::core::Abi for DEBUG_GET_TEXT_COMPLETIONS_IN {
type Abi = Self;
}
pub const DEBUG_GET_TEXT_COMPLETIONS_IS_DOT_COMMAND: u32 = 1u32;
pub const DEBUG_GET_TEXT_COMPLETIONS_IS_EXTENSION_COMMAND: u32 = 2u32;
pub const DEBUG_GET_TEXT_COMPLETIONS_IS_SYMBOL: u32 = 4u32;
pub const DEBUG_GET_TEXT_COMPLETIONS_NO_DOT_COMMANDS: u32 = 1u32;
pub const DEBUG_GET_TEXT_COMPLETIONS_NO_EXTENSION_COMMANDS: u32 = 2u32;
pub const DEBUG_GET_TEXT_COMPLETIONS_NO_SYMBOLS: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_GET_TEXT_COMPLETIONS_OUT {
pub Flags: u32,
pub ReplaceIndex: u32,
pub MatchCount: u32,
pub Reserved1: u32,
pub Reserved2: [u64; 2],
}
impl DEBUG_GET_TEXT_COMPLETIONS_OUT {}
impl ::core::default::Default for DEBUG_GET_TEXT_COMPLETIONS_OUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_GET_TEXT_COMPLETIONS_OUT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_GET_TEXT_COMPLETIONS_OUT").field("Flags", &self.Flags).field("ReplaceIndex", &self.ReplaceIndex).field("MatchCount", &self.MatchCount).field("Reserved1", &self.Reserved1).field("Reserved2", &self.Reserved2).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_GET_TEXT_COMPLETIONS_OUT {
fn eq(&self, other: &Self) -> bool {
self.Flags == other.Flags && self.ReplaceIndex == other.ReplaceIndex && self.MatchCount == other.MatchCount && self.Reserved1 == other.Reserved1 && self.Reserved2 == other.Reserved2
}
}
impl ::core::cmp::Eq for DEBUG_GET_TEXT_COMPLETIONS_OUT {}
unsafe impl ::windows::core::Abi for DEBUG_GET_TEXT_COMPLETIONS_OUT {
type Abi = Self;
}
pub const DEBUG_GSEL_ALLOW_HIGHER: u32 = 4u32;
pub const DEBUG_GSEL_ALLOW_LOWER: u32 = 2u32;
pub const DEBUG_GSEL_DEFAULT: u32 = 0u32;
pub const DEBUG_GSEL_INLINE_CALLSITE: u32 = 16u32;
pub const DEBUG_GSEL_NEAREST_ONLY: u32 = 8u32;
pub const DEBUG_GSEL_NO_SYMBOL_LOADS: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_HANDLE_DATA_BASIC {
pub TypeNameSize: u32,
pub ObjectNameSize: u32,
pub Attributes: u32,
pub GrantedAccess: u32,
pub HandleCount: u32,
pub PointerCount: u32,
}
impl DEBUG_HANDLE_DATA_BASIC {}
impl ::core::default::Default for DEBUG_HANDLE_DATA_BASIC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_HANDLE_DATA_BASIC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_HANDLE_DATA_BASIC")
.field("TypeNameSize", &self.TypeNameSize)
.field("ObjectNameSize", &self.ObjectNameSize)
.field("Attributes", &self.Attributes)
.field("GrantedAccess", &self.GrantedAccess)
.field("HandleCount", &self.HandleCount)
.field("PointerCount", &self.PointerCount)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_HANDLE_DATA_BASIC {
fn eq(&self, other: &Self) -> bool {
self.TypeNameSize == other.TypeNameSize && self.ObjectNameSize == other.ObjectNameSize && self.Attributes == other.Attributes && self.GrantedAccess == other.GrantedAccess && self.HandleCount == other.HandleCount && self.PointerCount == other.PointerCount
}
}
impl ::core::cmp::Eq for DEBUG_HANDLE_DATA_BASIC {}
unsafe impl ::windows::core::Abi for DEBUG_HANDLE_DATA_BASIC {
type Abi = Self;
}
pub const DEBUG_HANDLE_DATA_TYPE_ALL_HANDLE_OPERATIONS: u32 = 10u32;
pub const DEBUG_HANDLE_DATA_TYPE_BASIC: u32 = 0u32;
pub const DEBUG_HANDLE_DATA_TYPE_HANDLE_COUNT: u32 = 3u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_EVENT_1: u32 = 13u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_MUTANT_1: u32 = 7u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_MUTANT_2: u32 = 8u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_PROCESS_1: u32 = 11u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_PROCESS_2: u32 = 12u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_SECTION_1: u32 = 14u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_SEMAPHORE_1: u32 = 15u32;
pub const DEBUG_HANDLE_DATA_TYPE_MINI_THREAD_1: u32 = 6u32;
pub const DEBUG_HANDLE_DATA_TYPE_OBJECT_NAME: u32 = 2u32;
pub const DEBUG_HANDLE_DATA_TYPE_OBJECT_NAME_WIDE: u32 = 5u32;
pub const DEBUG_HANDLE_DATA_TYPE_PER_HANDLE_OPERATIONS: u32 = 9u32;
pub const DEBUG_HANDLE_DATA_TYPE_TYPE_NAME: u32 = 1u32;
pub const DEBUG_HANDLE_DATA_TYPE_TYPE_NAME_WIDE: u32 = 4u32;
pub const DEBUG_INTERRUPT_ACTIVE: u32 = 0u32;
pub const DEBUG_INTERRUPT_EXIT: u32 = 2u32;
pub const DEBUG_INTERRUPT_PASSIVE: u32 = 1u32;
pub const DEBUG_IOUTPUT_ADDR_TRANSLATE: u32 = 134217728u32;
pub const DEBUG_IOUTPUT_BREAKPOINT: u32 = 536870912u32;
pub const DEBUG_IOUTPUT_EVENT: u32 = 268435456u32;
pub const DEBUG_IOUTPUT_KD_PROTOCOL: u32 = 2147483648u32;
pub const DEBUG_IOUTPUT_REMOTING: u32 = 1073741824u32;
pub const DEBUG_KERNEL_ACTIVE_DUMP: u32 = 1030u32;
pub const DEBUG_KERNEL_CONNECTION: u32 = 0u32;
pub const DEBUG_KERNEL_DUMP: u32 = 1025u32;
pub const DEBUG_KERNEL_EXDI_DRIVER: u32 = 2u32;
pub const DEBUG_KERNEL_FULL_DUMP: u32 = 1026u32;
pub const DEBUG_KERNEL_IDNA: u32 = 3u32;
pub const DEBUG_KERNEL_INSTALL_DRIVER: u32 = 4u32;
pub const DEBUG_KERNEL_LOCAL: u32 = 1u32;
pub const DEBUG_KERNEL_REPT: u32 = 5u32;
pub const DEBUG_KERNEL_SMALL_DUMP: u32 = 1024u32;
pub const DEBUG_KERNEL_TRACE_LOG: u32 = 1028u32;
pub const DEBUG_KNOWN_STRUCT_GET_NAMES: u32 = 1u32;
pub const DEBUG_KNOWN_STRUCT_GET_SINGLE_LINE_OUTPUT: u32 = 2u32;
pub const DEBUG_KNOWN_STRUCT_SUPPRESS_TYPE_NAME: u32 = 3u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_BREAKPOINT {
pub Id: u32,
}
impl DEBUG_LAST_EVENT_INFO_BREAKPOINT {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_BREAKPOINT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_BREAKPOINT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_BREAKPOINT").field("Id", &self.Id).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_BREAKPOINT {
fn eq(&self, other: &Self) -> bool {
self.Id == other.Id
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_BREAKPOINT {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_BREAKPOINT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_LAST_EVENT_INFO_EXCEPTION {
pub ExceptionRecord: EXCEPTION_RECORD64,
pub FirstChance: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_LAST_EVENT_INFO_EXCEPTION {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_EXCEPTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_EXCEPTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_EXCEPTION").field("ExceptionRecord", &self.ExceptionRecord).field("FirstChance", &self.FirstChance).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_EXCEPTION {
fn eq(&self, other: &Self) -> bool {
self.ExceptionRecord == other.ExceptionRecord && self.FirstChance == other.FirstChance
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_EXCEPTION {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_EXCEPTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {
pub ExitCode: u32,
}
impl DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_EXIT_PROCESS").field("ExitCode", &self.ExitCode).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {
fn eq(&self, other: &Self) -> bool {
self.ExitCode == other.ExitCode
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_EXIT_PROCESS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_EXIT_THREAD {
pub ExitCode: u32,
}
impl DEBUG_LAST_EVENT_INFO_EXIT_THREAD {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_EXIT_THREAD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_EXIT_THREAD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_EXIT_THREAD").field("ExitCode", &self.ExitCode).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_EXIT_THREAD {
fn eq(&self, other: &Self) -> bool {
self.ExitCode == other.ExitCode
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_EXIT_THREAD {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_EXIT_THREAD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_LOAD_MODULE {
pub Base: u64,
}
impl DEBUG_LAST_EVENT_INFO_LOAD_MODULE {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_LOAD_MODULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_LOAD_MODULE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_LOAD_MODULE").field("Base", &self.Base).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_LOAD_MODULE {
fn eq(&self, other: &Self) -> bool {
self.Base == other.Base
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_LOAD_MODULE {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_LOAD_MODULE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {
pub Kind: u32,
pub DataSize: u32,
pub Address: u64,
}
impl DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION").field("Kind", &self.Kind).field("DataSize", &self.DataSize).field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {
fn eq(&self, other: &Self) -> bool {
self.Kind == other.Kind && self.DataSize == other.DataSize && self.Address == other.Address
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_SERVICE_EXCEPTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {
pub Error: u32,
pub Level: u32,
}
impl DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR").field("Error", &self.Error).field("Level", &self.Level).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {
fn eq(&self, other: &Self) -> bool {
self.Error == other.Error && self.Level == other.Level
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_SYSTEM_ERROR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {
pub Base: u64,
}
impl DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {}
impl ::core::default::Default for DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE").field("Base", &self.Base).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {
fn eq(&self, other: &Self) -> bool {
self.Base == other.Base
}
}
impl ::core::cmp::Eq for DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {}
unsafe impl ::windows::core::Abi for DEBUG_LAST_EVENT_INFO_UNLOAD_MODULE {
type Abi = Self;
}
pub const DEBUG_LEVEL_ASSEMBLY: u32 = 1u32;
pub const DEBUG_LEVEL_SOURCE: u32 = 0u32;
pub const DEBUG_LIVE_USER_NON_INVASIVE: u32 = 33u32;
pub const DEBUG_LOG_APPEND: u32 = 1u32;
pub const DEBUG_LOG_DEFAULT: u32 = 0u32;
pub const DEBUG_LOG_DML: u32 = 4u32;
pub const DEBUG_LOG_UNICODE: u32 = 2u32;
pub const DEBUG_MANAGED_ALLOWED: u32 = 1u32;
pub const DEBUG_MANAGED_DISABLED: u32 = 0u32;
pub const DEBUG_MANAGED_DLL_LOADED: u32 = 2u32;
pub const DEBUG_MANRESET_DEFAULT: u32 = 0u32;
pub const DEBUG_MANRESET_LOAD_DLL: u32 = 1u32;
pub const DEBUG_MANSTR_LOADED_SUPPORT_DLL: u32 = 1u32;
pub const DEBUG_MANSTR_LOAD_STATUS: u32 = 2u32;
pub const DEBUG_MANSTR_NONE: u32 = 0u32;
pub const DEBUG_MODNAME_IMAGE: u32 = 0u32;
pub const DEBUG_MODNAME_LOADED_IMAGE: u32 = 2u32;
pub const DEBUG_MODNAME_MAPPED_IMAGE: u32 = 4u32;
pub const DEBUG_MODNAME_MODULE: u32 = 1u32;
pub const DEBUG_MODNAME_SYMBOL_FILE: u32 = 3u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_MODULE_AND_ID {
pub ModuleBase: u64,
pub Id: u64,
}
impl DEBUG_MODULE_AND_ID {}
impl ::core::default::Default for DEBUG_MODULE_AND_ID {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_MODULE_AND_ID {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_MODULE_AND_ID").field("ModuleBase", &self.ModuleBase).field("Id", &self.Id).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_MODULE_AND_ID {
fn eq(&self, other: &Self) -> bool {
self.ModuleBase == other.ModuleBase && self.Id == other.Id
}
}
impl ::core::cmp::Eq for DEBUG_MODULE_AND_ID {}
unsafe impl ::windows::core::Abi for DEBUG_MODULE_AND_ID {
type Abi = Self;
}
pub const DEBUG_MODULE_EXE_MODULE: u32 = 4u32;
pub const DEBUG_MODULE_EXPLICIT: u32 = 8u32;
pub const DEBUG_MODULE_LOADED: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_MODULE_PARAMETERS {
pub Base: u64,
pub Size: u32,
pub TimeDateStamp: u32,
pub Checksum: u32,
pub Flags: u32,
pub SymbolType: u32,
pub ImageNameSize: u32,
pub ModuleNameSize: u32,
pub LoadedImageNameSize: u32,
pub SymbolFileNameSize: u32,
pub MappedImageNameSize: u32,
pub Reserved: [u64; 2],
}
impl DEBUG_MODULE_PARAMETERS {}
impl ::core::default::Default for DEBUG_MODULE_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_MODULE_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_MODULE_PARAMETERS")
.field("Base", &self.Base)
.field("Size", &self.Size)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("Checksum", &self.Checksum)
.field("Flags", &self.Flags)
.field("SymbolType", &self.SymbolType)
.field("ImageNameSize", &self.ImageNameSize)
.field("ModuleNameSize", &self.ModuleNameSize)
.field("LoadedImageNameSize", &self.LoadedImageNameSize)
.field("SymbolFileNameSize", &self.SymbolFileNameSize)
.field("MappedImageNameSize", &self.MappedImageNameSize)
.field("Reserved", &self.Reserved)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_MODULE_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.Base == other.Base
&& self.Size == other.Size
&& self.TimeDateStamp == other.TimeDateStamp
&& self.Checksum == other.Checksum
&& self.Flags == other.Flags
&& self.SymbolType == other.SymbolType
&& self.ImageNameSize == other.ImageNameSize
&& self.ModuleNameSize == other.ModuleNameSize
&& self.LoadedImageNameSize == other.LoadedImageNameSize
&& self.SymbolFileNameSize == other.SymbolFileNameSize
&& self.MappedImageNameSize == other.MappedImageNameSize
&& self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_MODULE_PARAMETERS {}
unsafe impl ::windows::core::Abi for DEBUG_MODULE_PARAMETERS {
type Abi = Self;
}
pub const DEBUG_MODULE_SECONDARY: u32 = 16u32;
pub const DEBUG_MODULE_SYM_BAD_CHECKSUM: u32 = 65536u32;
pub const DEBUG_MODULE_SYNTHETIC: u32 = 32u32;
pub const DEBUG_MODULE_UNLOADED: u32 = 1u32;
pub const DEBUG_MODULE_USER_MODE: u32 = 2u32;
pub const DEBUG_NOTIFY_SESSION_ACCESSIBLE: u32 = 2u32;
pub const DEBUG_NOTIFY_SESSION_ACTIVE: u32 = 0u32;
pub const DEBUG_NOTIFY_SESSION_INACCESSIBLE: u32 = 3u32;
pub const DEBUG_NOTIFY_SESSION_INACTIVE: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_OFFSET_REGION {
pub Base: u64,
pub Size: u64,
}
impl DEBUG_OFFSET_REGION {}
impl ::core::default::Default for DEBUG_OFFSET_REGION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_OFFSET_REGION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_OFFSET_REGION").field("Base", &self.Base).field("Size", &self.Size).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_OFFSET_REGION {
fn eq(&self, other: &Self) -> bool {
self.Base == other.Base && self.Size == other.Size
}
}
impl ::core::cmp::Eq for DEBUG_OFFSET_REGION {}
unsafe impl ::windows::core::Abi for DEBUG_OFFSET_REGION {
type Abi = Self;
}
pub const DEBUG_OFFSINFO_VIRTUAL_SOURCE: u32 = 1u32;
pub const DEBUG_OUTCBF_COMBINED_EXPLICIT_FLUSH: u32 = 1u32;
pub const DEBUG_OUTCBF_DML_HAS_SPECIAL_CHARACTERS: u32 = 4u32;
pub const DEBUG_OUTCBF_DML_HAS_TAGS: u32 = 2u32;
pub const DEBUG_OUTCBI_ANY_FORMAT: u32 = 6u32;
pub const DEBUG_OUTCBI_DML: u32 = 4u32;
pub const DEBUG_OUTCBI_EXPLICIT_FLUSH: u32 = 1u32;
pub const DEBUG_OUTCBI_TEXT: u32 = 2u32;
pub const DEBUG_OUTCB_DML: u32 = 1u32;
pub const DEBUG_OUTCB_EXPLICIT_FLUSH: u32 = 2u32;
pub const DEBUG_OUTCB_TEXT: u32 = 0u32;
pub const DEBUG_OUTCTL_ALL_CLIENTS: u32 = 1u32;
pub const DEBUG_OUTCTL_ALL_OTHER_CLIENTS: u32 = 2u32;
pub const DEBUG_OUTCTL_AMBIENT: u32 = 4294967295u32;
pub const DEBUG_OUTCTL_AMBIENT_DML: u32 = 4294967294u32;
pub const DEBUG_OUTCTL_AMBIENT_TEXT: u32 = 4294967295u32;
pub const DEBUG_OUTCTL_DML: u32 = 32u32;
pub const DEBUG_OUTCTL_IGNORE: u32 = 3u32;
pub const DEBUG_OUTCTL_LOG_ONLY: u32 = 4u32;
pub const DEBUG_OUTCTL_NOT_LOGGED: u32 = 8u32;
pub const DEBUG_OUTCTL_OVERRIDE_MASK: u32 = 16u32;
pub const DEBUG_OUTCTL_SEND_MASK: u32 = 7u32;
pub const DEBUG_OUTCTL_THIS_CLIENT: u32 = 0u32;
pub const DEBUG_OUTPUT_DEBUGGEE: u32 = 128u32;
pub const DEBUG_OUTPUT_DEBUGGEE_PROMPT: u32 = 256u32;
pub const DEBUG_OUTPUT_ERROR: u32 = 2u32;
pub const DEBUG_OUTPUT_EXTENSION_WARNING: u32 = 64u32;
pub const DEBUG_OUTPUT_IDENTITY_DEFAULT: u32 = 0u32;
pub const DEBUG_OUTPUT_NORMAL: u32 = 1u32;
pub const DEBUG_OUTPUT_PROMPT: u32 = 16u32;
pub const DEBUG_OUTPUT_PROMPT_REGISTERS: u32 = 32u32;
pub const DEBUG_OUTPUT_STATUS: u32 = 1024u32;
pub const DEBUG_OUTPUT_SYMBOLS: u32 = 512u32;
pub const DEBUG_OUTPUT_SYMBOLS_DEFAULT: u32 = 0u32;
pub const DEBUG_OUTPUT_SYMBOLS_NO_NAMES: u32 = 1u32;
pub const DEBUG_OUTPUT_SYMBOLS_NO_OFFSETS: u32 = 2u32;
pub const DEBUG_OUTPUT_SYMBOLS_NO_TYPES: u32 = 16u32;
pub const DEBUG_OUTPUT_SYMBOLS_NO_VALUES: u32 = 4u32;
pub const DEBUG_OUTPUT_VERBOSE: u32 = 8u32;
pub const DEBUG_OUTPUT_WARNING: u32 = 4u32;
pub const DEBUG_OUTPUT_XML: u32 = 2048u32;
pub const DEBUG_OUTSYM_ALLOW_DISPLACEMENT: u32 = 4u32;
pub const DEBUG_OUTSYM_DEFAULT: u32 = 0u32;
pub const DEBUG_OUTSYM_FORCE_OFFSET: u32 = 1u32;
pub const DEBUG_OUTSYM_SOURCE_LINE: u32 = 2u32;
pub const DEBUG_OUTTYPE_ADDRESS_AT_END: u32 = 131072u32;
pub const DEBUG_OUTTYPE_ADDRESS_OF_FIELD: u32 = 65536u32;
pub const DEBUG_OUTTYPE_BLOCK_RECURSE: u32 = 2097152u32;
pub const DEBUG_OUTTYPE_COMPACT_OUTPUT: u32 = 8u32;
pub const DEBUG_OUTTYPE_DEFAULT: u32 = 0u32;
pub const DEBUG_OUTTYPE_NO_INDENT: u32 = 1u32;
pub const DEBUG_OUTTYPE_NO_OFFSET: u32 = 2u32;
pub const DEBUG_OUTTYPE_VERBOSE: u32 = 4u32;
pub const DEBUG_OUT_TEXT_REPL_DEFAULT: u32 = 0u32;
pub const DEBUG_PHYSICAL_CACHED: u32 = 1u32;
pub const DEBUG_PHYSICAL_DEFAULT: u32 = 0u32;
pub const DEBUG_PHYSICAL_UNCACHED: u32 = 2u32;
pub const DEBUG_PHYSICAL_WRITE_COMBINED: u32 = 3u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union DEBUG_PROCESSOR_IDENTIFICATION_ALL {
pub Alpha: DEBUG_PROCESSOR_IDENTIFICATION_ALPHA,
pub Amd64: DEBUG_PROCESSOR_IDENTIFICATION_AMD64,
pub Ia64: DEBUG_PROCESSOR_IDENTIFICATION_IA64,
pub X86: DEBUG_PROCESSOR_IDENTIFICATION_X86,
pub Arm: DEBUG_PROCESSOR_IDENTIFICATION_ARM,
pub Arm64: DEBUG_PROCESSOR_IDENTIFICATION_ARM64,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_ALL {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_ALL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_ALL {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_ALL {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_ALL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {
pub Type: u32,
pub Revision: u32,
}
impl DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {}
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_ALPHA").field("Type", &self.Type).field("Revision", &self.Revision).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {
fn eq(&self, other: &Self) -> bool {
self.Type == other.Type && self.Revision == other.Revision
}
}
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {}
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_ALPHA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {
pub Family: u32,
pub Model: u32,
pub Stepping: u32,
pub VendorString: [super::super::super::Foundation::CHAR; 16],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_AMD64").field("Family", &self.Family).field("Model", &self.Model).field("Stepping", &self.Stepping).field("VendorString", &self.VendorString).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {
fn eq(&self, other: &Self) -> bool {
self.Family == other.Family && self.Model == other.Model && self.Stepping == other.Stepping && self.VendorString == other.VendorString
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_AMD64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_ARM {
pub Model: u32,
pub Revision: u32,
pub VendorString: [super::super::super::Foundation::CHAR; 16],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_ARM {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_ARM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_ARM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_ARM").field("Model", &self.Model).field("Revision", &self.Revision).field("VendorString", &self.VendorString).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_ARM {
fn eq(&self, other: &Self) -> bool {
self.Model == other.Model && self.Revision == other.Revision && self.VendorString == other.VendorString
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_ARM {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_ARM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {
pub Model: u32,
pub Revision: u32,
pub VendorString: [super::super::super::Foundation::CHAR; 16],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_ARM64").field("Model", &self.Model).field("Revision", &self.Revision).field("VendorString", &self.VendorString).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {
fn eq(&self, other: &Self) -> bool {
self.Model == other.Model && self.Revision == other.Revision && self.VendorString == other.VendorString
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_ARM64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_IA64 {
pub Model: u32,
pub Revision: u32,
pub Family: u32,
pub ArchRev: u32,
pub VendorString: [super::super::super::Foundation::CHAR; 16],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_IA64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_IA64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_IA64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_IA64").field("Model", &self.Model).field("Revision", &self.Revision).field("Family", &self.Family).field("ArchRev", &self.ArchRev).field("VendorString", &self.VendorString).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_IA64 {
fn eq(&self, other: &Self) -> bool {
self.Model == other.Model && self.Revision == other.Revision && self.Family == other.Family && self.ArchRev == other.ArchRev && self.VendorString == other.VendorString
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_IA64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_IA64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_PROCESSOR_IDENTIFICATION_X86 {
pub Family: u32,
pub Model: u32,
pub Stepping: u32,
pub VendorString: [super::super::super::Foundation::CHAR; 16],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_PROCESSOR_IDENTIFICATION_X86 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_PROCESSOR_IDENTIFICATION_X86 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_PROCESSOR_IDENTIFICATION_X86 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_PROCESSOR_IDENTIFICATION_X86").field("Family", &self.Family).field("Model", &self.Model).field("Stepping", &self.Stepping).field("VendorString", &self.VendorString).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_PROCESSOR_IDENTIFICATION_X86 {
fn eq(&self, other: &Self) -> bool {
self.Family == other.Family && self.Model == other.Model && self.Stepping == other.Stepping && self.VendorString == other.VendorString
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_PROCESSOR_IDENTIFICATION_X86 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_PROCESSOR_IDENTIFICATION_X86 {
type Abi = Self;
}
pub const DEBUG_PROCESS_DETACH_ON_EXIT: u32 = 1u32;
pub const DEBUG_PROCESS_ONLY_THIS_PROCESS: u32 = 2u32;
pub const DEBUG_PROC_DESC_DEFAULT: u32 = 0u32;
pub const DEBUG_PROC_DESC_NO_COMMAND_LINE: u32 = 8u32;
pub const DEBUG_PROC_DESC_NO_MTS_PACKAGES: u32 = 4u32;
pub const DEBUG_PROC_DESC_NO_PATHS: u32 = 1u32;
pub const DEBUG_PROC_DESC_NO_SERVICES: u32 = 2u32;
pub const DEBUG_PROC_DESC_NO_SESSION_ID: u32 = 16u32;
pub const DEBUG_PROC_DESC_NO_USER_NAME: u32 = 32u32;
pub const DEBUG_PROC_DESC_WITH_PACKAGEFAMILY: u32 = 64u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_READ_USER_MINIDUMP_STREAM {
pub StreamType: u32,
pub Flags: u32,
pub Offset: u64,
pub Buffer: *mut ::core::ffi::c_void,
pub BufferSize: u32,
pub BufferUsed: u32,
}
impl DEBUG_READ_USER_MINIDUMP_STREAM {}
impl ::core::default::Default for DEBUG_READ_USER_MINIDUMP_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_READ_USER_MINIDUMP_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_READ_USER_MINIDUMP_STREAM").field("StreamType", &self.StreamType).field("Flags", &self.Flags).field("Offset", &self.Offset).field("Buffer", &self.Buffer).field("BufferSize", &self.BufferSize).field("BufferUsed", &self.BufferUsed).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_READ_USER_MINIDUMP_STREAM {
fn eq(&self, other: &Self) -> bool {
self.StreamType == other.StreamType && self.Flags == other.Flags && self.Offset == other.Offset && self.Buffer == other.Buffer && self.BufferSize == other.BufferSize && self.BufferUsed == other.BufferUsed
}
}
impl ::core::cmp::Eq for DEBUG_READ_USER_MINIDUMP_STREAM {}
unsafe impl ::windows::core::Abi for DEBUG_READ_USER_MINIDUMP_STREAM {
type Abi = Self;
}
pub const DEBUG_REGISTERS_ALL: u32 = 7u32;
pub const DEBUG_REGISTERS_DEFAULT: u32 = 0u32;
pub const DEBUG_REGISTERS_FLOAT: u32 = 4u32;
pub const DEBUG_REGISTERS_INT32: u32 = 1u32;
pub const DEBUG_REGISTERS_INT64: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_REGISTER_DESCRIPTION {
pub Type: u32,
pub Flags: u32,
pub SubregMaster: u32,
pub SubregLength: u32,
pub SubregMask: u64,
pub SubregShift: u32,
pub Reserved0: u32,
}
impl DEBUG_REGISTER_DESCRIPTION {}
impl ::core::default::Default for DEBUG_REGISTER_DESCRIPTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_REGISTER_DESCRIPTION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_REGISTER_DESCRIPTION")
.field("Type", &self.Type)
.field("Flags", &self.Flags)
.field("SubregMaster", &self.SubregMaster)
.field("SubregLength", &self.SubregLength)
.field("SubregMask", &self.SubregMask)
.field("SubregShift", &self.SubregShift)
.field("Reserved0", &self.Reserved0)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_REGISTER_DESCRIPTION {
fn eq(&self, other: &Self) -> bool {
self.Type == other.Type && self.Flags == other.Flags && self.SubregMaster == other.SubregMaster && self.SubregLength == other.SubregLength && self.SubregMask == other.SubregMask && self.SubregShift == other.SubregShift && self.Reserved0 == other.Reserved0
}
}
impl ::core::cmp::Eq for DEBUG_REGISTER_DESCRIPTION {}
unsafe impl ::windows::core::Abi for DEBUG_REGISTER_DESCRIPTION {
type Abi = Self;
}
pub const DEBUG_REGISTER_SUB_REGISTER: u32 = 1u32;
pub const DEBUG_REGSRC_DEBUGGEE: u32 = 0u32;
pub const DEBUG_REGSRC_EXPLICIT: u32 = 1u32;
pub const DEBUG_REGSRC_FRAME: u32 = 2u32;
pub const DEBUG_REQUEST_ADD_CACHED_SYMBOL_INFO: u32 = 16u32;
pub const DEBUG_REQUEST_CLOSE_TOKEN: u32 = 30u32;
pub const DEBUG_REQUEST_CURRENT_OUTPUT_CALLBACKS_ARE_DML_AWARE: u32 = 19u32;
pub const DEBUG_REQUEST_DUPLICATE_TOKEN: u32 = 28u32;
pub const DEBUG_REQUEST_EXT_TYPED_DATA_ANSI: u32 = 12u32;
pub const DEBUG_REQUEST_GET_ADDITIONAL_CREATE_OPTIONS: u32 = 4u32;
pub const DEBUG_REQUEST_GET_CACHED_SYMBOL_INFO: u32 = 15u32;
pub const DEBUG_REQUEST_GET_CAPTURED_EVENT_CODE_OFFSET: u32 = 10u32;
pub const DEBUG_REQUEST_GET_DUMP_HEADER: u32 = 21u32;
pub const DEBUG_REQUEST_GET_EXTENSION_SEARCH_PATH_WIDE: u32 = 13u32;
pub const DEBUG_REQUEST_GET_INSTRUMENTATION_VERSION: u32 = 37u32;
pub const DEBUG_REQUEST_GET_MODULE_ARCHITECTURE: u32 = 38u32;
pub const DEBUG_REQUEST_GET_OFFSET_UNWIND_INFORMATION: u32 = 20u32;
pub const DEBUG_REQUEST_GET_TEXT_COMPLETIONS_ANSI: u32 = 18u32;
pub const DEBUG_REQUEST_GET_TEXT_COMPLETIONS_WIDE: u32 = 14u32;
pub const DEBUG_REQUEST_GET_WIN32_MAJOR_MINOR_VERSIONS: u32 = 6u32;
pub const DEBUG_REQUEST_INLINE_QUERY: u32 = 35u32;
pub const DEBUG_REQUEST_MIDORI: u32 = 23u32;
pub const DEBUG_REQUEST_MISC_INFORMATION: u32 = 25u32;
pub const DEBUG_REQUEST_OPEN_PROCESS_TOKEN: u32 = 26u32;
pub const DEBUG_REQUEST_OPEN_THREAD_TOKEN: u32 = 27u32;
pub const DEBUG_REQUEST_PROCESS_DESCRIPTORS: u32 = 24u32;
pub const DEBUG_REQUEST_QUERY_INFO_TOKEN: u32 = 29u32;
pub const DEBUG_REQUEST_READ_CAPTURED_EVENT_CODE_STREAM: u32 = 11u32;
pub const DEBUG_REQUEST_READ_USER_MINIDUMP_STREAM: u32 = 7u32;
pub const DEBUG_REQUEST_REMOVE_CACHED_SYMBOL_INFO: u32 = 17u32;
pub const DEBUG_REQUEST_RESUME_THREAD: u32 = 34u32;
pub const DEBUG_REQUEST_SET_ADDITIONAL_CREATE_OPTIONS: u32 = 5u32;
pub const DEBUG_REQUEST_SET_DUMP_HEADER: u32 = 22u32;
pub const DEBUG_REQUEST_SET_LOCAL_IMPLICIT_COMMAND_LINE: u32 = 9u32;
pub const DEBUG_REQUEST_SOURCE_PATH_HAS_SOURCE_SERVER: u32 = 0u32;
pub const DEBUG_REQUEST_TARGET_CAN_DETACH: u32 = 8u32;
pub const DEBUG_REQUEST_TARGET_EXCEPTION_CONTEXT: u32 = 1u32;
pub const DEBUG_REQUEST_TARGET_EXCEPTION_RECORD: u32 = 3u32;
pub const DEBUG_REQUEST_TARGET_EXCEPTION_THREAD: u32 = 2u32;
pub const DEBUG_REQUEST_TL_INSTRUMENTATION_AWARE: u32 = 36u32;
pub const DEBUG_REQUEST_WOW_MODULE: u32 = 32u32;
pub const DEBUG_REQUEST_WOW_PROCESS: u32 = 31u32;
pub const DEBUG_SCOPE_GROUP_ALL: u32 = 3u32;
pub const DEBUG_SCOPE_GROUP_ARGUMENTS: u32 = 1u32;
pub const DEBUG_SCOPE_GROUP_BY_DATAMODEL: u32 = 4u32;
pub const DEBUG_SCOPE_GROUP_LOCALS: u32 = 2u32;
pub const DEBUG_SERVERS_ALL: u32 = 3u32;
pub const DEBUG_SERVERS_DEBUGGER: u32 = 1u32;
pub const DEBUG_SERVERS_PROCESS: u32 = 2u32;
pub const DEBUG_SESSION_ACTIVE: u32 = 0u32;
pub const DEBUG_SESSION_END: u32 = 4u32;
pub const DEBUG_SESSION_END_SESSION_ACTIVE_DETACH: u32 = 2u32;
pub const DEBUG_SESSION_END_SESSION_ACTIVE_TERMINATE: u32 = 1u32;
pub const DEBUG_SESSION_END_SESSION_PASSIVE: u32 = 3u32;
pub const DEBUG_SESSION_FAILURE: u32 = 7u32;
pub const DEBUG_SESSION_HIBERNATE: u32 = 6u32;
pub const DEBUG_SESSION_REBOOT: u32 = 5u32;
pub const DEBUG_SOURCE_IS_STATEMENT: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_SPECIFIC_FILTER_PARAMETERS {
pub ExecutionOption: u32,
pub ContinueOption: u32,
pub TextSize: u32,
pub CommandSize: u32,
pub ArgumentSize: u32,
}
impl DEBUG_SPECIFIC_FILTER_PARAMETERS {}
impl ::core::default::Default for DEBUG_SPECIFIC_FILTER_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_SPECIFIC_FILTER_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_SPECIFIC_FILTER_PARAMETERS").field("ExecutionOption", &self.ExecutionOption).field("ContinueOption", &self.ContinueOption).field("TextSize", &self.TextSize).field("CommandSize", &self.CommandSize).field("ArgumentSize", &self.ArgumentSize).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_SPECIFIC_FILTER_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.ExecutionOption == other.ExecutionOption && self.ContinueOption == other.ContinueOption && self.TextSize == other.TextSize && self.CommandSize == other.CommandSize && self.ArgumentSize == other.ArgumentSize
}
}
impl ::core::cmp::Eq for DEBUG_SPECIFIC_FILTER_PARAMETERS {}
unsafe impl ::windows::core::Abi for DEBUG_SPECIFIC_FILTER_PARAMETERS {
type Abi = Self;
}
pub const DEBUG_SRCFILE_SYMBOL_CHECKSUMINFO: u32 = 2u32;
pub const DEBUG_SRCFILE_SYMBOL_TOKEN: u32 = 0u32;
pub const DEBUG_SRCFILE_SYMBOL_TOKEN_SOURCE_COMMAND_WIDE: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DEBUG_STACKFRAME_TYPE(pub i32);
pub const DST_SCRIPT_FRAME: DEBUG_STACKFRAME_TYPE = DEBUG_STACKFRAME_TYPE(0i32);
pub const DST_INTERNAL_FRAME: DEBUG_STACKFRAME_TYPE = DEBUG_STACKFRAME_TYPE(1i32);
pub const DST_INVOCATION_FRAME: DEBUG_STACKFRAME_TYPE = DEBUG_STACKFRAME_TYPE(2i32);
impl ::core::convert::From<i32> for DEBUG_STACKFRAME_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DEBUG_STACKFRAME_TYPE {
type Abi = Self;
}
pub const DEBUG_STACK_ARGUMENTS: u32 = 1u32;
pub const DEBUG_STACK_COLUMN_NAMES: u32 = 16u32;
pub const DEBUG_STACK_DML: u32 = 2048u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_STACK_FRAME {
pub InstructionOffset: u64,
pub ReturnOffset: u64,
pub FrameOffset: u64,
pub StackOffset: u64,
pub FuncTableEntry: u64,
pub Params: [u64; 4],
pub Reserved: [u64; 6],
pub Virtual: super::super::super::Foundation::BOOL,
pub FrameNumber: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_STACK_FRAME {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_STACK_FRAME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_STACK_FRAME {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_STACK_FRAME")
.field("InstructionOffset", &self.InstructionOffset)
.field("ReturnOffset", &self.ReturnOffset)
.field("FrameOffset", &self.FrameOffset)
.field("StackOffset", &self.StackOffset)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Reserved", &self.Reserved)
.field("Virtual", &self.Virtual)
.field("FrameNumber", &self.FrameNumber)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_STACK_FRAME {
fn eq(&self, other: &Self) -> bool {
self.InstructionOffset == other.InstructionOffset && self.ReturnOffset == other.ReturnOffset && self.FrameOffset == other.FrameOffset && self.StackOffset == other.StackOffset && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Reserved == other.Reserved && self.Virtual == other.Virtual && self.FrameNumber == other.FrameNumber
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_STACK_FRAME {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_STACK_FRAME {
type Abi = Self;
}
pub const DEBUG_STACK_FRAME_ADDRESSES: u32 = 8u32;
pub const DEBUG_STACK_FRAME_ADDRESSES_RA_ONLY: u32 = 256u32;
pub const DEBUG_STACK_FRAME_ARCH: u32 = 16384u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_STACK_FRAME_EX {
pub InstructionOffset: u64,
pub ReturnOffset: u64,
pub FrameOffset: u64,
pub StackOffset: u64,
pub FuncTableEntry: u64,
pub Params: [u64; 4],
pub Reserved: [u64; 6],
pub Virtual: super::super::super::Foundation::BOOL,
pub FrameNumber: u32,
pub InlineFrameContext: u32,
pub Reserved1: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_STACK_FRAME_EX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_STACK_FRAME_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_STACK_FRAME_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_STACK_FRAME_EX")
.field("InstructionOffset", &self.InstructionOffset)
.field("ReturnOffset", &self.ReturnOffset)
.field("FrameOffset", &self.FrameOffset)
.field("StackOffset", &self.StackOffset)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Reserved", &self.Reserved)
.field("Virtual", &self.Virtual)
.field("FrameNumber", &self.FrameNumber)
.field("InlineFrameContext", &self.InlineFrameContext)
.field("Reserved1", &self.Reserved1)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_STACK_FRAME_EX {
fn eq(&self, other: &Self) -> bool {
self.InstructionOffset == other.InstructionOffset && self.ReturnOffset == other.ReturnOffset && self.FrameOffset == other.FrameOffset && self.StackOffset == other.StackOffset && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Reserved == other.Reserved && self.Virtual == other.Virtual && self.FrameNumber == other.FrameNumber && self.InlineFrameContext == other.InlineFrameContext && self.Reserved1 == other.Reserved1
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_STACK_FRAME_EX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_STACK_FRAME_EX {
type Abi = Self;
}
pub const DEBUG_STACK_FRAME_MEMORY_USAGE: u32 = 512u32;
pub const DEBUG_STACK_FRAME_NUMBERS: u32 = 64u32;
pub const DEBUG_STACK_FRAME_OFFSETS: u32 = 4096u32;
pub const DEBUG_STACK_FUNCTION_INFO: u32 = 2u32;
pub const DEBUG_STACK_NONVOLATILE_REGISTERS: u32 = 32u32;
pub const DEBUG_STACK_PARAMETERS: u32 = 128u32;
pub const DEBUG_STACK_PARAMETERS_NEWLINE: u32 = 1024u32;
pub const DEBUG_STACK_PROVIDER: u32 = 8192u32;
pub const DEBUG_STACK_SOURCE_LINE: u32 = 4u32;
pub const DEBUG_STATUS_BREAK: u32 = 6u32;
pub const DEBUG_STATUS_GO: u32 = 1u32;
pub const DEBUG_STATUS_GO_HANDLED: u32 = 2u32;
pub const DEBUG_STATUS_GO_NOT_HANDLED: u32 = 3u32;
pub const DEBUG_STATUS_IGNORE_EVENT: u32 = 9u32;
pub const DEBUG_STATUS_INSIDE_WAIT: u64 = 4294967296u64;
pub const DEBUG_STATUS_MASK: u32 = 31u32;
pub const DEBUG_STATUS_NO_CHANGE: u32 = 0u32;
pub const DEBUG_STATUS_NO_DEBUGGEE: u32 = 7u32;
pub const DEBUG_STATUS_OUT_OF_SYNC: u32 = 15u32;
pub const DEBUG_STATUS_RESTART_REQUESTED: u32 = 10u32;
pub const DEBUG_STATUS_REVERSE_GO: u32 = 11u32;
pub const DEBUG_STATUS_REVERSE_STEP_BRANCH: u32 = 12u32;
pub const DEBUG_STATUS_REVERSE_STEP_INTO: u32 = 14u32;
pub const DEBUG_STATUS_REVERSE_STEP_OVER: u32 = 13u32;
pub const DEBUG_STATUS_STEP_BRANCH: u32 = 8u32;
pub const DEBUG_STATUS_STEP_INTO: u32 = 5u32;
pub const DEBUG_STATUS_STEP_OVER: u32 = 4u32;
pub const DEBUG_STATUS_TIMEOUT: u32 = 17u32;
pub const DEBUG_STATUS_WAIT_INPUT: u32 = 16u32;
pub const DEBUG_STATUS_WAIT_TIMEOUT: u64 = 8589934592u64;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_SYMBOL_ENTRY {
pub ModuleBase: u64,
pub Offset: u64,
pub Id: u64,
pub Arg64: u64,
pub Size: u32,
pub Flags: u32,
pub TypeId: u32,
pub NameSize: u32,
pub Token: u32,
pub Tag: u32,
pub Arg32: u32,
pub Reserved: u32,
}
impl DEBUG_SYMBOL_ENTRY {}
impl ::core::default::Default for DEBUG_SYMBOL_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_SYMBOL_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_SYMBOL_ENTRY")
.field("ModuleBase", &self.ModuleBase)
.field("Offset", &self.Offset)
.field("Id", &self.Id)
.field("Arg64", &self.Arg64)
.field("Size", &self.Size)
.field("Flags", &self.Flags)
.field("TypeId", &self.TypeId)
.field("NameSize", &self.NameSize)
.field("Token", &self.Token)
.field("Tag", &self.Tag)
.field("Arg32", &self.Arg32)
.field("Reserved", &self.Reserved)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_SYMBOL_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.ModuleBase == other.ModuleBase && self.Offset == other.Offset && self.Id == other.Id && self.Arg64 == other.Arg64 && self.Size == other.Size && self.Flags == other.Flags && self.TypeId == other.TypeId && self.NameSize == other.NameSize && self.Token == other.Token && self.Tag == other.Tag && self.Arg32 == other.Arg32 && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_SYMBOL_ENTRY {}
unsafe impl ::windows::core::Abi for DEBUG_SYMBOL_ENTRY {
type Abi = Self;
}
pub const DEBUG_SYMBOL_EXPANDED: u32 = 16u32;
pub const DEBUG_SYMBOL_EXPANSION_LEVEL_MASK: u32 = 15u32;
pub const DEBUG_SYMBOL_IS_ARGUMENT: u32 = 256u32;
pub const DEBUG_SYMBOL_IS_ARRAY: u32 = 64u32;
pub const DEBUG_SYMBOL_IS_FLOAT: u32 = 128u32;
pub const DEBUG_SYMBOL_IS_LOCAL: u32 = 512u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_SYMBOL_PARAMETERS {
pub Module: u64,
pub TypeId: u32,
pub ParentSymbol: u32,
pub SubElements: u32,
pub Flags: u32,
pub Reserved: u64,
}
impl DEBUG_SYMBOL_PARAMETERS {}
impl ::core::default::Default for DEBUG_SYMBOL_PARAMETERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_SYMBOL_PARAMETERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_SYMBOL_PARAMETERS").field("Module", &self.Module).field("TypeId", &self.TypeId).field("ParentSymbol", &self.ParentSymbol).field("SubElements", &self.SubElements).field("Flags", &self.Flags).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_SYMBOL_PARAMETERS {
fn eq(&self, other: &Self) -> bool {
self.Module == other.Module && self.TypeId == other.TypeId && self.ParentSymbol == other.ParentSymbol && self.SubElements == other.SubElements && self.Flags == other.Flags && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_SYMBOL_PARAMETERS {}
unsafe impl ::windows::core::Abi for DEBUG_SYMBOL_PARAMETERS {
type Abi = Self;
}
pub const DEBUG_SYMBOL_READ_ONLY: u32 = 32u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_SYMBOL_SOURCE_ENTRY {
pub ModuleBase: u64,
pub Offset: u64,
pub FileNameId: u64,
pub EngineInternal: u64,
pub Size: u32,
pub Flags: u32,
pub FileNameSize: u32,
pub StartLine: u32,
pub EndLine: u32,
pub StartColumn: u32,
pub EndColumn: u32,
pub Reserved: u32,
}
impl DEBUG_SYMBOL_SOURCE_ENTRY {}
impl ::core::default::Default for DEBUG_SYMBOL_SOURCE_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_SYMBOL_SOURCE_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_SYMBOL_SOURCE_ENTRY")
.field("ModuleBase", &self.ModuleBase)
.field("Offset", &self.Offset)
.field("FileNameId", &self.FileNameId)
.field("EngineInternal", &self.EngineInternal)
.field("Size", &self.Size)
.field("Flags", &self.Flags)
.field("FileNameSize", &self.FileNameSize)
.field("StartLine", &self.StartLine)
.field("EndLine", &self.EndLine)
.field("StartColumn", &self.StartColumn)
.field("EndColumn", &self.EndColumn)
.field("Reserved", &self.Reserved)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_SYMBOL_SOURCE_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.ModuleBase == other.ModuleBase && self.Offset == other.Offset && self.FileNameId == other.FileNameId && self.EngineInternal == other.EngineInternal && self.Size == other.Size && self.Flags == other.Flags && self.FileNameSize == other.FileNameSize && self.StartLine == other.StartLine && self.EndLine == other.EndLine && self.StartColumn == other.StartColumn && self.EndColumn == other.EndColumn && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for DEBUG_SYMBOL_SOURCE_ENTRY {}
unsafe impl ::windows::core::Abi for DEBUG_SYMBOL_SOURCE_ENTRY {
type Abi = Self;
}
pub const DEBUG_SYMENT_IS_CODE: u32 = 1u32;
pub const DEBUG_SYMENT_IS_DATA: u32 = 2u32;
pub const DEBUG_SYMENT_IS_LOCAL: u32 = 8u32;
pub const DEBUG_SYMENT_IS_MANAGED: u32 = 16u32;
pub const DEBUG_SYMENT_IS_PARAMETER: u32 = 4u32;
pub const DEBUG_SYMENT_IS_SYNTHETIC: u32 = 32u32;
pub const DEBUG_SYMINFO_BREAKPOINT_SOURCE_LINE: u32 = 0u32;
pub const DEBUG_SYMINFO_GET_MODULE_SYMBOL_NAMES_AND_OFFSETS: u32 = 3u32;
pub const DEBUG_SYMINFO_GET_SYMBOL_NAME_BY_OFFSET_AND_TAG_WIDE: u32 = 2u32;
pub const DEBUG_SYMINFO_IMAGEHLP_MODULEW64: u32 = 1u32;
pub const DEBUG_SYMTYPE_CODEVIEW: u32 = 2u32;
pub const DEBUG_SYMTYPE_COFF: u32 = 1u32;
pub const DEBUG_SYMTYPE_DEFERRED: u32 = 5u32;
pub const DEBUG_SYMTYPE_DIA: u32 = 7u32;
pub const DEBUG_SYMTYPE_EXPORT: u32 = 4u32;
pub const DEBUG_SYMTYPE_NONE: u32 = 0u32;
pub const DEBUG_SYMTYPE_PDB: u32 = 3u32;
pub const DEBUG_SYMTYPE_SYM: u32 = 6u32;
pub const DEBUG_SYSOBJINFO_CURRENT_PROCESS_COOKIE: u32 = 2u32;
pub const DEBUG_SYSOBJINFO_THREAD_BASIC_INFORMATION: u32 = 0u32;
pub const DEBUG_SYSOBJINFO_THREAD_NAME_WIDE: u32 = 1u32;
pub const DEBUG_SYSVERSTR_BUILD: u32 = 1u32;
pub const DEBUG_SYSVERSTR_SERVICE_PACK: u32 = 0u32;
pub const DEBUG_TBINFO_AFFINITY: u32 = 32u32;
pub const DEBUG_TBINFO_ALL: u32 = 63u32;
pub const DEBUG_TBINFO_EXIT_STATUS: u32 = 1u32;
pub const DEBUG_TBINFO_PRIORITY: u32 = 4u32;
pub const DEBUG_TBINFO_PRIORITY_CLASS: u32 = 2u32;
pub const DEBUG_TBINFO_START_OFFSET: u32 = 16u32;
pub const DEBUG_TBINFO_TIMES: u32 = 8u32;
pub const DEBUG_TEXT_ALLOWBREAKPOINTS: u32 = 8u32;
pub const DEBUG_TEXT_ALLOWERRORREPORT: u32 = 16u32;
pub const DEBUG_TEXT_EVALUATETOCODECONTEXT: u32 = 32u32;
pub const DEBUG_TEXT_ISEXPRESSION: u32 = 1u32;
pub const DEBUG_TEXT_ISNONUSERCODE: u32 = 64u32;
pub const DEBUG_TEXT_NOSIDEEFFECTS: u32 = 4u32;
pub const DEBUG_TEXT_RETURNVALUE: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_THREAD_BASIC_INFORMATION {
pub Valid: u32,
pub ExitStatus: u32,
pub PriorityClass: u32,
pub Priority: u32,
pub CreateTime: u64,
pub ExitTime: u64,
pub KernelTime: u64,
pub UserTime: u64,
pub StartOffset: u64,
pub Affinity: u64,
}
impl DEBUG_THREAD_BASIC_INFORMATION {}
impl ::core::default::Default for DEBUG_THREAD_BASIC_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_THREAD_BASIC_INFORMATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_THREAD_BASIC_INFORMATION")
.field("Valid", &self.Valid)
.field("ExitStatus", &self.ExitStatus)
.field("PriorityClass", &self.PriorityClass)
.field("Priority", &self.Priority)
.field("CreateTime", &self.CreateTime)
.field("ExitTime", &self.ExitTime)
.field("KernelTime", &self.KernelTime)
.field("UserTime", &self.UserTime)
.field("StartOffset", &self.StartOffset)
.field("Affinity", &self.Affinity)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_THREAD_BASIC_INFORMATION {
fn eq(&self, other: &Self) -> bool {
self.Valid == other.Valid && self.ExitStatus == other.ExitStatus && self.PriorityClass == other.PriorityClass && self.Priority == other.Priority && self.CreateTime == other.CreateTime && self.ExitTime == other.ExitTime && self.KernelTime == other.KernelTime && self.UserTime == other.UserTime && self.StartOffset == other.StartOffset && self.Affinity == other.Affinity
}
}
impl ::core::cmp::Eq for DEBUG_THREAD_BASIC_INFORMATION {}
unsafe impl ::windows::core::Abi for DEBUG_THREAD_BASIC_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DEBUG_TYPED_DATA {
pub ModBase: u64,
pub Offset: u64,
pub EngineHandle: u64,
pub Data: u64,
pub Size: u32,
pub Flags: u32,
pub TypeId: u32,
pub BaseTypeId: u32,
pub Tag: u32,
pub Register: u32,
pub Internal: [u64; 9],
}
impl DEBUG_TYPED_DATA {}
impl ::core::default::Default for DEBUG_TYPED_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DEBUG_TYPED_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DEBUG_TYPED_DATA")
.field("ModBase", &self.ModBase)
.field("Offset", &self.Offset)
.field("EngineHandle", &self.EngineHandle)
.field("Data", &self.Data)
.field("Size", &self.Size)
.field("Flags", &self.Flags)
.field("TypeId", &self.TypeId)
.field("BaseTypeId", &self.BaseTypeId)
.field("Tag", &self.Tag)
.field("Register", &self.Register)
.field("Internal", &self.Internal)
.finish()
}
}
impl ::core::cmp::PartialEq for DEBUG_TYPED_DATA {
fn eq(&self, other: &Self) -> bool {
self.ModBase == other.ModBase && self.Offset == other.Offset && self.EngineHandle == other.EngineHandle && self.Data == other.Data && self.Size == other.Size && self.Flags == other.Flags && self.TypeId == other.TypeId && self.BaseTypeId == other.BaseTypeId && self.Tag == other.Tag && self.Register == other.Register && self.Internal == other.Internal
}
}
impl ::core::cmp::Eq for DEBUG_TYPED_DATA {}
unsafe impl ::windows::core::Abi for DEBUG_TYPED_DATA {
type Abi = Self;
}
pub const DEBUG_TYPED_DATA_IS_IN_MEMORY: u32 = 1u32;
pub const DEBUG_TYPED_DATA_PHYSICAL_CACHED: u32 = 4u32;
pub const DEBUG_TYPED_DATA_PHYSICAL_DEFAULT: u32 = 2u32;
pub const DEBUG_TYPED_DATA_PHYSICAL_MEMORY: u32 = 14u32;
pub const DEBUG_TYPED_DATA_PHYSICAL_UNCACHED: u32 = 6u32;
pub const DEBUG_TYPED_DATA_PHYSICAL_WRITE_COMBINED: u32 = 8u32;
pub const DEBUG_TYPEOPTS_FORCERADIX_OUTPUT: u32 = 4u32;
pub const DEBUG_TYPEOPTS_LONGSTATUS_DISPLAY: u32 = 2u32;
pub const DEBUG_TYPEOPTS_MATCH_MAXSIZE: u32 = 8u32;
pub const DEBUG_TYPEOPTS_UNICODE_DISPLAY: u32 = 1u32;
pub const DEBUG_USER_WINDOWS_DUMP: u32 = 1025u32;
pub const DEBUG_USER_WINDOWS_DUMP_WINDOWS_CE: u32 = 1029u32;
pub const DEBUG_USER_WINDOWS_IDNA: u32 = 2u32;
pub const DEBUG_USER_WINDOWS_PROCESS: u32 = 0u32;
pub const DEBUG_USER_WINDOWS_PROCESS_SERVER: u32 = 1u32;
pub const DEBUG_USER_WINDOWS_REPT: u32 = 3u32;
pub const DEBUG_USER_WINDOWS_SMALL_DUMP: u32 = 1024u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_VALUE {
pub Anonymous: DEBUG_VALUE_0,
pub TailOfRawBytes: u32,
pub Type: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_VALUE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_VALUE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_VALUE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_VALUE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_VALUE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union DEBUG_VALUE_0 {
pub I8: u8,
pub I16: u16,
pub I32: u32,
pub Anonymous: DEBUG_VALUE_0_0,
pub F32: f32,
pub F64: f64,
pub F80Bytes: [u8; 10],
pub F82Bytes: [u8; 11],
pub F128Bytes: [u8; 16],
pub VI8: [u8; 16],
pub VI16: [u16; 8],
pub VI32: [u32; 4],
pub VI64: [u64; 2],
pub VF32: [f32; 4],
pub VF64: [f64; 2],
pub I64Parts32: DEBUG_VALUE_0_2,
pub F128Parts64: DEBUG_VALUE_0_1,
pub RawBytes: [u8; 24],
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_VALUE_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_VALUE_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_VALUE_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_VALUE_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_VALUE_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_VALUE_0_0 {
pub I64: u64,
pub Nat: super::super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_VALUE_0_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_VALUE_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_VALUE_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("I64", &self.I64).field("Nat", &self.Nat).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_VALUE_0_0 {
fn eq(&self, other: &Self) -> bool {
self.I64 == other.I64 && self.Nat == other.Nat
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_VALUE_0_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_VALUE_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_VALUE_0_1 {
pub LowPart: u64,
pub HighPart: i64,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_VALUE_0_1 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_VALUE_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_VALUE_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_F128Parts64_e__Struct").field("LowPart", &self.LowPart).field("HighPart", &self.HighPart).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_VALUE_0_1 {
fn eq(&self, other: &Self) -> bool {
self.LowPart == other.LowPart && self.HighPart == other.HighPart
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_VALUE_0_1 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_VALUE_0_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DEBUG_VALUE_0_2 {
pub LowPart: u32,
pub HighPart: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl DEBUG_VALUE_0_2 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DEBUG_VALUE_0_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DEBUG_VALUE_0_2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_I64Parts32_e__Struct").field("LowPart", &self.LowPart).field("HighPart", &self.HighPart).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DEBUG_VALUE_0_2 {
fn eq(&self, other: &Self) -> bool {
self.LowPart == other.LowPart && self.HighPart == other.HighPart
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DEBUG_VALUE_0_2 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DEBUG_VALUE_0_2 {
type Abi = Self;
}
pub const DEBUG_VALUE_FLOAT128: u32 = 9u32;
pub const DEBUG_VALUE_FLOAT32: u32 = 5u32;
pub const DEBUG_VALUE_FLOAT64: u32 = 6u32;
pub const DEBUG_VALUE_FLOAT80: u32 = 7u32;
pub const DEBUG_VALUE_FLOAT82: u32 = 8u32;
pub const DEBUG_VALUE_INT16: u32 = 2u32;
pub const DEBUG_VALUE_INT32: u32 = 3u32;
pub const DEBUG_VALUE_INT64: u32 = 4u32;
pub const DEBUG_VALUE_INT8: u32 = 1u32;
pub const DEBUG_VALUE_INVALID: u32 = 0u32;
pub const DEBUG_VALUE_TYPES: u32 = 12u32;
pub const DEBUG_VALUE_VECTOR128: u32 = 11u32;
pub const DEBUG_VALUE_VECTOR64: u32 = 10u32;
pub const DEBUG_VSEARCH_DEFAULT: u32 = 0u32;
pub const DEBUG_VSEARCH_WRITABLE_ONLY: u32 = 1u32;
pub const DEBUG_VSOURCE_DEBUGGEE: u32 = 1u32;
pub const DEBUG_VSOURCE_DUMP_WITHOUT_MEMINFO: u32 = 3u32;
pub const DEBUG_VSOURCE_INVALID: u32 = 0u32;
pub const DEBUG_VSOURCE_MAPPED_IMAGE: u32 = 2u32;
pub const DEBUG_WAIT_DEFAULT: u32 = 0u32;
#[cfg(feature = "Win32_Foundation")]
pub type DIGEST_FUNCTION = unsafe extern "system" fn(refdata: *mut ::core::ffi::c_void, pdata: *mut u8, dwlength: u32) -> super::super::super::Foundation::BOOL;
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct DISPATCHER_CONTEXT {
pub ControlPc: usize,
pub ImageBase: usize,
pub FunctionEntry: *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY,
pub EstablisherFrame: usize,
pub TargetPc: usize,
pub ContextRecord: *mut CONTEXT,
pub LanguageHandler: ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE>,
pub HandlerData: *mut ::core::ffi::c_void,
pub HistoryTable: *mut UNWIND_HISTORY_TABLE,
pub ScopeIndex: u32,
pub ControlPcIsUnwound: super::super::super::Foundation::BOOLEAN,
pub NonVolatileRegisters: *mut u8,
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl DISPATCHER_CONTEXT {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for DISPATCHER_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for DISPATCHER_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DISPATCHER_CONTEXT")
.field("ControlPc", &self.ControlPc)
.field("ImageBase", &self.ImageBase)
.field("FunctionEntry", &self.FunctionEntry)
.field("EstablisherFrame", &self.EstablisherFrame)
.field("TargetPc", &self.TargetPc)
.field("ContextRecord", &self.ContextRecord)
.field("HandlerData", &self.HandlerData)
.field("HistoryTable", &self.HistoryTable)
.field("ScopeIndex", &self.ScopeIndex)
.field("ControlPcIsUnwound", &self.ControlPcIsUnwound)
.field("NonVolatileRegisters", &self.NonVolatileRegisters)
.finish()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for DISPATCHER_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.ControlPc == other.ControlPc
&& self.ImageBase == other.ImageBase
&& self.FunctionEntry == other.FunctionEntry
&& self.EstablisherFrame == other.EstablisherFrame
&& self.TargetPc == other.TargetPc
&& self.ContextRecord == other.ContextRecord
&& self.LanguageHandler.map(|f| f as usize) == other.LanguageHandler.map(|f| f as usize)
&& self.HandlerData == other.HandlerData
&& self.HistoryTable == other.HistoryTable
&& self.ScopeIndex == other.ScopeIndex
&& self.ControlPcIsUnwound == other.ControlPcIsUnwound
&& self.NonVolatileRegisters == other.NonVolatileRegisters
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for DISPATCHER_CONTEXT {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for DISPATCHER_CONTEXT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct DISPATCHER_CONTEXT {
pub ControlPc: u64,
pub ImageBase: u64,
pub FunctionEntry: *mut IMAGE_RUNTIME_FUNCTION_ENTRY,
pub EstablisherFrame: u64,
pub TargetIp: u64,
pub ContextRecord: *mut CONTEXT,
pub LanguageHandler: ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE>,
pub HandlerData: *mut ::core::ffi::c_void,
pub HistoryTable: *mut UNWIND_HISTORY_TABLE,
pub ScopeIndex: u32,
pub Fill0: u32,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl DISPATCHER_CONTEXT {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for DISPATCHER_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for DISPATCHER_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DISPATCHER_CONTEXT")
.field("ControlPc", &self.ControlPc)
.field("ImageBase", &self.ImageBase)
.field("FunctionEntry", &self.FunctionEntry)
.field("EstablisherFrame", &self.EstablisherFrame)
.field("TargetIp", &self.TargetIp)
.field("ContextRecord", &self.ContextRecord)
.field("HandlerData", &self.HandlerData)
.field("HistoryTable", &self.HistoryTable)
.field("ScopeIndex", &self.ScopeIndex)
.field("Fill0", &self.Fill0)
.finish()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for DISPATCHER_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.ControlPc == other.ControlPc && self.ImageBase == other.ImageBase && self.FunctionEntry == other.FunctionEntry && self.EstablisherFrame == other.EstablisherFrame && self.TargetIp == other.TargetIp && self.ContextRecord == other.ContextRecord && self.LanguageHandler.map(|f| f as usize) == other.LanguageHandler.map(|f| f as usize) && self.HandlerData == other.HandlerData && self.HistoryTable == other.HistoryTable && self.ScopeIndex == other.ScopeIndex && self.Fill0 == other.Fill0
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for DISPATCHER_CONTEXT {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for DISPATCHER_CONTEXT {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const DMP_CONTEXT_RECORD_SIZE_32: u32 = 1200u32;
pub const DMP_CONTEXT_RECORD_SIZE_64: u32 = 3000u32;
pub const DMP_HEADER_COMMENT_SIZE: u32 = 128u32;
pub const DMP_PHYSICAL_MEMORY_BLOCK_SIZE_32: u32 = 700u32;
pub const DMP_PHYSICAL_MEMORY_BLOCK_SIZE_64: u32 = 700u32;
pub const DMP_RESERVED_0_SIZE_32: u32 = 1760u32;
pub const DMP_RESERVED_0_SIZE_64: u32 = 4008u32;
pub const DMP_RESERVED_2_SIZE_32: u32 = 16u32;
pub const DMP_RESERVED_3_SIZE_32: u32 = 56u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DOCUMENTNAMETYPE(pub i32);
pub const DOCUMENTNAMETYPE_APPNODE: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(0i32);
pub const DOCUMENTNAMETYPE_TITLE: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(1i32);
pub const DOCUMENTNAMETYPE_FILE_TAIL: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(2i32);
pub const DOCUMENTNAMETYPE_URL: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(3i32);
pub const DOCUMENTNAMETYPE_UNIQUE_TITLE: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(4i32);
pub const DOCUMENTNAMETYPE_SOURCE_MAP_URL: DOCUMENTNAMETYPE = DOCUMENTNAMETYPE(5i32);
impl ::core::convert::From<i32> for DOCUMENTNAMETYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DOCUMENTNAMETYPE {
type Abi = Self;
}
pub const DSLFLAG_MISMATCHED_DBG: u32 = 2u32;
pub const DSLFLAG_MISMATCHED_PDB: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union DUMP_FILE_ATTRIBUTES {
pub Anonymous: DUMP_FILE_ATTRIBUTES_0,
pub Attributes: u32,
}
impl DUMP_FILE_ATTRIBUTES {}
impl ::core::default::Default for DUMP_FILE_ATTRIBUTES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for DUMP_FILE_ATTRIBUTES {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for DUMP_FILE_ATTRIBUTES {}
unsafe impl ::windows::core::Abi for DUMP_FILE_ATTRIBUTES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct DUMP_FILE_ATTRIBUTES_0 {
pub _bitfield: u32,
}
impl DUMP_FILE_ATTRIBUTES_0 {}
impl ::core::default::Default for DUMP_FILE_ATTRIBUTES_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for DUMP_FILE_ATTRIBUTES_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for DUMP_FILE_ATTRIBUTES_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for DUMP_FILE_ATTRIBUTES_0 {}
unsafe impl ::windows::core::Abi for DUMP_FILE_ATTRIBUTES_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DUMP_HEADER32 {
pub Signature: u32,
pub ValidDump: u32,
pub MajorVersion: u32,
pub MinorVersion: u32,
pub DirectoryTableBase: u32,
pub PfnDataBase: u32,
pub PsLoadedModuleList: u32,
pub PsActiveProcessHead: u32,
pub MachineImageType: u32,
pub NumberProcessors: u32,
pub BugCheckCode: u32,
pub BugCheckParameter1: u32,
pub BugCheckParameter2: u32,
pub BugCheckParameter3: u32,
pub BugCheckParameter4: u32,
pub VersionUser: [super::super::super::Foundation::CHAR; 32],
pub PaeEnabled: u8,
pub KdSecondaryVersion: u8,
pub Spare3: [u8; 2],
pub KdDebuggerDataBlock: u32,
pub Anonymous: DUMP_HEADER32_0,
pub ContextRecord: [u8; 1200],
pub Exception: EXCEPTION_RECORD32,
pub Comment: [super::super::super::Foundation::CHAR; 128],
pub Attributes: DUMP_FILE_ATTRIBUTES,
pub BootId: u32,
pub _reserved0: [u8; 1760],
pub DumpType: u32,
pub MiniDumpFields: u32,
pub SecondaryDataState: u32,
pub ProductType: u32,
pub SuiteMask: u32,
pub WriterStatus: u32,
pub RequiredDumpSpace: i64,
pub _reserved2: [u8; 16],
pub SystemUpTime: i64,
pub SystemTime: i64,
pub _reserved3: [u8; 56],
}
#[cfg(feature = "Win32_Foundation")]
impl DUMP_HEADER32 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DUMP_HEADER32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DUMP_HEADER32 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DUMP_HEADER32 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DUMP_HEADER32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union DUMP_HEADER32_0 {
pub PhysicalMemoryBlock: PHYSICAL_MEMORY_DESCRIPTOR32,
pub PhysicalMemoryBlockBuffer: [u8; 700],
}
#[cfg(feature = "Win32_Foundation")]
impl DUMP_HEADER32_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DUMP_HEADER32_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DUMP_HEADER32_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DUMP_HEADER32_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DUMP_HEADER32_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DUMP_HEADER64 {
pub Signature: u32,
pub ValidDump: u32,
pub MajorVersion: u32,
pub MinorVersion: u32,
pub DirectoryTableBase: u64,
pub PfnDataBase: u64,
pub PsLoadedModuleList: u64,
pub PsActiveProcessHead: u64,
pub MachineImageType: u32,
pub NumberProcessors: u32,
pub BugCheckCode: u32,
pub BugCheckParameter1: u64,
pub BugCheckParameter2: u64,
pub BugCheckParameter3: u64,
pub BugCheckParameter4: u64,
pub VersionUser: [super::super::super::Foundation::CHAR; 32],
pub KdDebuggerDataBlock: u64,
pub Anonymous: DUMP_HEADER64_0,
pub ContextRecord: [u8; 3000],
pub Exception: EXCEPTION_RECORD64,
pub DumpType: u32,
pub RequiredDumpSpace: i64,
pub SystemTime: i64,
pub Comment: [super::super::super::Foundation::CHAR; 128],
pub SystemUpTime: i64,
pub MiniDumpFields: u32,
pub SecondaryDataState: u32,
pub ProductType: u32,
pub SuiteMask: u32,
pub WriterStatus: u32,
pub Unused1: u8,
pub KdSecondaryVersion: u8,
pub Unused: [u8; 2],
pub Attributes: DUMP_FILE_ATTRIBUTES,
pub BootId: u32,
pub _reserved0: [u8; 4008],
}
#[cfg(feature = "Win32_Foundation")]
impl DUMP_HEADER64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DUMP_HEADER64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DUMP_HEADER64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DUMP_HEADER64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DUMP_HEADER64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union DUMP_HEADER64_0 {
pub PhysicalMemoryBlock: PHYSICAL_MEMORY_DESCRIPTOR64,
pub PhysicalMemoryBlockBuffer: [u8; 700],
}
#[cfg(feature = "Win32_Foundation")]
impl DUMP_HEADER64_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DUMP_HEADER64_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DUMP_HEADER64_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DUMP_HEADER64_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DUMP_HEADER64_0 {
type Abi = Self;
}
pub const DUMP_SUMMARY_VALID_CURRENT_USER_VA: u32 = 2u32;
pub const DUMP_SUMMARY_VALID_KERNEL_VA: u32 = 1u32;
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DbgHelpCreateUserDump<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, callback: ::core::option::Option<PDBGHELP_CREATE_USER_DUMP_CALLBACK>, userdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DbgHelpCreateUserDump(filename: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, userdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DbgHelpCreateUserDump(filename.into_param().abi(), ::core::mem::transmute(callback), ::core::mem::transmute(userdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DbgHelpCreateUserDumpW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(filename: Param0, callback: ::core::option::Option<PDBGHELP_CREATE_USER_DUMP_CALLBACK>, userdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DbgHelpCreateUserDumpW(filename: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, userdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DbgHelpCreateUserDumpW(filename.into_param().abi(), ::core::mem::transmute(callback), ::core::mem::transmute(userdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugActiveProcess(dwprocessid: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugActiveProcess(dwprocessid: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DebugActiveProcess(::core::mem::transmute(dwprocessid)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugActiveProcessStop(dwprocessid: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugActiveProcessStop(dwprocessid: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DebugActiveProcessStop(::core::mem::transmute(dwprocessid)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct DebugBaseEventCallbacks(pub ::windows::core::IUnknown);
impl DebugBaseEventCallbacks {
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Breakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Exception(&self, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(exception), ::core::mem::transmute(firstchance)).ok()
}
pub unsafe fn CreateThread(&self, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(dataoffset), ::core::mem::transmute(startoffset)).ok()
}
pub unsafe fn ExitThread(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: Param4, imagename: Param5, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(handle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(initialthreadhandle),
::core::mem::transmute(threaddataoffset),
::core::mem::transmute(startoffset),
)
.ok()
}
pub unsafe fn ExitProcess(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadModule<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: Param3, imagename: Param4, checksum: u32, timedatestamp: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagefilehandle), ::core::mem::transmute(baseoffset), ::core::mem::transmute(modulesize), modulename.into_param().abi(), imagename.into_param().abi(), ::core::mem::transmute(checksum), ::core::mem::transmute(timedatestamp)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagebasename: Param0, baseoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), imagebasename.into_param().abi(), ::core::mem::transmute(baseoffset)).ok()
}
pub unsafe fn SystemError(&self, error: u32, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(error), ::core::mem::transmute(level)).ok()
}
pub unsafe fn SessionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn ChangeDebuggeeState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeEngineState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeSymbolState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
}
unsafe impl ::windows::core::Interface for DebugBaseEventCallbacks {
type Vtable = DebugBaseEventCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::zeroed();
}
impl ::core::convert::From<DebugBaseEventCallbacks> for ::windows::core::IUnknown {
fn from(value: DebugBaseEventCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&DebugBaseEventCallbacks> for ::windows::core::IUnknown {
fn from(value: &DebugBaseEventCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for DebugBaseEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a DebugBaseEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<DebugBaseEventCallbacks> for IDebugEventCallbacks {
fn from(value: DebugBaseEventCallbacks) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&DebugBaseEventCallbacks> for IDebugEventCallbacks {
fn from(value: &DebugBaseEventCallbacks) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugEventCallbacks> for DebugBaseEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, IDebugEventCallbacks> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugEventCallbacks> for &DebugBaseEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, IDebugEventCallbacks> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct DebugBaseEventCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PSTR, imagename: super::super::super::Foundation::PSTR, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PSTR, imagename: super::super::super::Foundation::PSTR, checksum: u32, timedatestamp: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebasename: super::super::super::Foundation::PSTR, baseoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: u32, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct DebugBaseEventCallbacksWide(pub ::windows::core::IUnknown);
impl DebugBaseEventCallbacksWide {
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Breakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Exception(&self, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(exception), ::core::mem::transmute(firstchance)).ok()
}
pub unsafe fn CreateThread(&self, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(dataoffset), ::core::mem::transmute(startoffset)).ok()
}
pub unsafe fn ExitThread(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: Param4, imagename: Param5, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(handle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(initialthreadhandle),
::core::mem::transmute(threaddataoffset),
::core::mem::transmute(startoffset),
)
.ok()
}
pub unsafe fn ExitProcess(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadModule<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: Param3, imagename: Param4, checksum: u32, timedatestamp: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagefilehandle), ::core::mem::transmute(baseoffset), ::core::mem::transmute(modulesize), modulename.into_param().abi(), imagename.into_param().abi(), ::core::mem::transmute(checksum), ::core::mem::transmute(timedatestamp)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagebasename: Param0, baseoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), imagebasename.into_param().abi(), ::core::mem::transmute(baseoffset)).ok()
}
pub unsafe fn SystemError(&self, error: u32, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(error), ::core::mem::transmute(level)).ok()
}
pub unsafe fn SessionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn ChangeDebuggeeState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeEngineState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeSymbolState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
}
unsafe impl ::windows::core::Interface for DebugBaseEventCallbacksWide {
type Vtable = DebugBaseEventCallbacksWide_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::zeroed();
}
impl ::core::convert::From<DebugBaseEventCallbacksWide> for ::windows::core::IUnknown {
fn from(value: DebugBaseEventCallbacksWide) -> Self {
value.0
}
}
impl ::core::convert::From<&DebugBaseEventCallbacksWide> for ::windows::core::IUnknown {
fn from(value: &DebugBaseEventCallbacksWide) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for DebugBaseEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a DebugBaseEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<DebugBaseEventCallbacksWide> for IDebugEventCallbacksWide {
fn from(value: DebugBaseEventCallbacksWide) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&DebugBaseEventCallbacksWide> for IDebugEventCallbacksWide {
fn from(value: &DebugBaseEventCallbacksWide) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugEventCallbacksWide> for DebugBaseEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, IDebugEventCallbacksWide> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugEventCallbacksWide> for &DebugBaseEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, IDebugEventCallbacksWide> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct DebugBaseEventCallbacksWide_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebasename: super::super::super::Foundation::PWSTR, baseoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: u32, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
);
#[inline]
pub unsafe fn DebugBreak() {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugBreak();
}
::core::mem::transmute(DebugBreak())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugBreakProcess<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(process: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugBreakProcess(process: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DebugBreakProcess(process.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugConnect<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(remoteoptions: Param0, interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugConnect(remoteoptions: super::super::super::Foundation::PSTR, interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DebugConnect(remoteoptions.into_param().abi(), ::core::mem::transmute(interfaceid), ::core::mem::transmute(interface)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugConnectWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(remoteoptions: Param0, interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugConnectWide(remoteoptions: super::super::super::Foundation::PWSTR, interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DebugConnectWide(remoteoptions.into_param().abi(), ::core::mem::transmute(interfaceid), ::core::mem::transmute(interface)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn DebugCreate(interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugCreate(interfaceid: *const ::windows::core::GUID, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DebugCreate(::core::mem::transmute(interfaceid), ::core::mem::transmute(interface)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn DebugCreateEx(interfaceid: *const ::windows::core::GUID, dbgengoptions: u32, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugCreateEx(interfaceid: *const ::windows::core::GUID, dbgengoptions: u32, interface: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DebugCreateEx(::core::mem::transmute(interfaceid), ::core::mem::transmute(dbgengoptions), ::core::mem::transmute(interface)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const DebugHelper: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0bfcc060_8c1d_11d0_accd_00aa0060275c);
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DebugPropertyInfo {
pub m_dwValidFields: u32,
pub m_bstrName: super::super::super::Foundation::BSTR,
pub m_bstrType: super::super::super::Foundation::BSTR,
pub m_bstrValue: super::super::super::Foundation::BSTR,
pub m_bstrFullName: super::super::super::Foundation::BSTR,
pub m_dwAttrib: u32,
pub m_pDebugProp: ::core::option::Option<IDebugProperty>,
}
#[cfg(feature = "Win32_Foundation")]
impl DebugPropertyInfo {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DebugPropertyInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DebugPropertyInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DebugPropertyInfo")
.field("m_dwValidFields", &self.m_dwValidFields)
.field("m_bstrName", &self.m_bstrName)
.field("m_bstrType", &self.m_bstrType)
.field("m_bstrValue", &self.m_bstrValue)
.field("m_bstrFullName", &self.m_bstrFullName)
.field("m_dwAttrib", &self.m_dwAttrib)
.field("m_pDebugProp", &self.m_pDebugProp)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DebugPropertyInfo {
fn eq(&self, other: &Self) -> bool {
self.m_dwValidFields == other.m_dwValidFields && self.m_bstrName == other.m_bstrName && self.m_bstrType == other.m_bstrType && self.m_bstrValue == other.m_bstrValue && self.m_bstrFullName == other.m_bstrFullName && self.m_dwAttrib == other.m_dwAttrib && self.m_pDebugProp == other.m_pDebugProp
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DebugPropertyInfo {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DebugPropertyInfo {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DebugSetProcessKillOnExit<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(killonexit: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DebugSetProcessKillOnExit(killonexit: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(DebugSetProcessKillOnExit(killonexit.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DebugStackFrameDescriptor {
pub pdsf: ::core::option::Option<IDebugStackFrame>,
pub dwMin: u32,
pub dwLim: u32,
pub fFinal: super::super::super::Foundation::BOOL,
pub punkFinal: ::core::option::Option<::windows::core::IUnknown>,
}
#[cfg(feature = "Win32_Foundation")]
impl DebugStackFrameDescriptor {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DebugStackFrameDescriptor {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DebugStackFrameDescriptor {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DebugStackFrameDescriptor").field("pdsf", &self.pdsf).field("dwMin", &self.dwMin).field("dwLim", &self.dwLim).field("fFinal", &self.fFinal).field("punkFinal", &self.punkFinal).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DebugStackFrameDescriptor {
fn eq(&self, other: &Self) -> bool {
self.pdsf == other.pdsf && self.dwMin == other.dwMin && self.dwLim == other.dwLim && self.fFinal == other.fFinal && self.punkFinal == other.punkFinal
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DebugStackFrameDescriptor {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DebugStackFrameDescriptor {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct DebugStackFrameDescriptor64 {
pub pdsf: ::core::option::Option<IDebugStackFrame>,
pub dwMin: u64,
pub dwLim: u64,
pub fFinal: super::super::super::Foundation::BOOL,
pub punkFinal: ::core::option::Option<::windows::core::IUnknown>,
}
#[cfg(feature = "Win32_Foundation")]
impl DebugStackFrameDescriptor64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for DebugStackFrameDescriptor64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for DebugStackFrameDescriptor64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("DebugStackFrameDescriptor64").field("pdsf", &self.pdsf).field("dwMin", &self.dwMin).field("dwLim", &self.dwLim).field("fFinal", &self.fFinal).field("punkFinal", &self.punkFinal).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for DebugStackFrameDescriptor64 {
fn eq(&self, other: &Self) -> bool {
self.pdsf == other.pdsf && self.dwMin == other.dwMin && self.dwLim == other.dwLim && self.fFinal == other.fFinal && self.punkFinal == other.punkFinal
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for DebugStackFrameDescriptor64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for DebugStackFrameDescriptor64 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[inline]
pub unsafe fn DecodePointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DecodePointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(DecodePointer(::core::mem::transmute(ptr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn DecodeRemotePointer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(processhandle: Param0, ptr: *const ::core::ffi::c_void, decodedptr: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DecodeRemotePointer(processhandle: super::super::super::Foundation::HANDLE, ptr: *const ::core::ffi::c_void, decodedptr: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
DecodeRemotePointer(processhandle.into_param().abi(), ::core::mem::transmute(ptr), ::core::mem::transmute(decodedptr)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn DecodeSystemPointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn DecodeSystemPointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(DecodeSystemPointer(::core::mem::transmute(ptr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const DefaultDebugSessionProvider: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x834128a2_51f4_11d0_8f20_00805f2cd064);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ERRORRESUMEACTION(pub i32);
pub const ERRORRESUMEACTION_ReexecuteErrorStatement: ERRORRESUMEACTION = ERRORRESUMEACTION(0i32);
pub const ERRORRESUMEACTION_AbortCallAndReturnErrorToCaller: ERRORRESUMEACTION = ERRORRESUMEACTION(1i32);
pub const ERRORRESUMEACTION_SkipErrorStatement: ERRORRESUMEACTION = ERRORRESUMEACTION(2i32);
impl ::core::convert::From<i32> for ERRORRESUMEACTION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ERRORRESUMEACTION {
type Abi = Self;
}
pub const ERROR_DBG_CANCELLED: u32 = 3221226695u32;
pub const ERROR_DBG_TIMEOUT: u32 = 3221226932u32;
pub const ERROR_IMAGE_NOT_STRIPPED: u32 = 34816u32;
pub const ERROR_NO_DBG_POINTER: u32 = 34817u32;
pub const ERROR_NO_PDB_POINTER: u32 = 34818u32;
pub const ESLFLAG_FULLPATH: u32 = 1u32;
pub const ESLFLAG_INLINE_SITE: u32 = 16u32;
pub const ESLFLAG_NEAREST: u32 = 2u32;
pub const ESLFLAG_NEXT: u32 = 8u32;
pub const ESLFLAG_PREV: u32 = 4u32;
pub const EVENT_SRCSPEW: u32 = 100u32;
pub const EVENT_SRCSPEW_END: u32 = 199u32;
pub const EVENT_SRCSPEW_START: u32 = 100u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXCEPTION_DEBUG_INFO {
pub ExceptionRecord: EXCEPTION_RECORD,
pub dwFirstChance: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl EXCEPTION_DEBUG_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXCEPTION_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXCEPTION_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXCEPTION_DEBUG_INFO").field("ExceptionRecord", &self.ExceptionRecord).field("dwFirstChance", &self.dwFirstChance).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXCEPTION_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.ExceptionRecord == other.ExceptionRecord && self.dwFirstChance == other.dwFirstChance
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXCEPTION_DEBUG_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXCEPTION_DEBUG_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct EXCEPTION_POINTERS {
pub ExceptionRecord: *mut EXCEPTION_RECORD,
pub ContextRecord: *mut CONTEXT,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl EXCEPTION_POINTERS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for EXCEPTION_POINTERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for EXCEPTION_POINTERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXCEPTION_POINTERS").field("ExceptionRecord", &self.ExceptionRecord).field("ContextRecord", &self.ContextRecord).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for EXCEPTION_POINTERS {
fn eq(&self, other: &Self) -> bool {
self.ExceptionRecord == other.ExceptionRecord && self.ContextRecord == other.ContextRecord
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for EXCEPTION_POINTERS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for EXCEPTION_POINTERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXCEPTION_RECORD {
pub ExceptionCode: super::super::super::Foundation::NTSTATUS,
pub ExceptionFlags: u32,
pub ExceptionRecord: *mut EXCEPTION_RECORD,
pub ExceptionAddress: *mut ::core::ffi::c_void,
pub NumberParameters: u32,
pub ExceptionInformation: [usize; 15],
}
#[cfg(feature = "Win32_Foundation")]
impl EXCEPTION_RECORD {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXCEPTION_RECORD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXCEPTION_RECORD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXCEPTION_RECORD")
.field("ExceptionCode", &self.ExceptionCode)
.field("ExceptionFlags", &self.ExceptionFlags)
.field("ExceptionRecord", &self.ExceptionRecord)
.field("ExceptionAddress", &self.ExceptionAddress)
.field("NumberParameters", &self.NumberParameters)
.field("ExceptionInformation", &self.ExceptionInformation)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXCEPTION_RECORD {
fn eq(&self, other: &Self) -> bool {
self.ExceptionCode == other.ExceptionCode && self.ExceptionFlags == other.ExceptionFlags && self.ExceptionRecord == other.ExceptionRecord && self.ExceptionAddress == other.ExceptionAddress && self.NumberParameters == other.NumberParameters && self.ExceptionInformation == other.ExceptionInformation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXCEPTION_RECORD {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXCEPTION_RECORD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXCEPTION_RECORD32 {
pub ExceptionCode: super::super::super::Foundation::NTSTATUS,
pub ExceptionFlags: u32,
pub ExceptionRecord: u32,
pub ExceptionAddress: u32,
pub NumberParameters: u32,
pub ExceptionInformation: [u32; 15],
}
#[cfg(feature = "Win32_Foundation")]
impl EXCEPTION_RECORD32 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXCEPTION_RECORD32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXCEPTION_RECORD32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXCEPTION_RECORD32")
.field("ExceptionCode", &self.ExceptionCode)
.field("ExceptionFlags", &self.ExceptionFlags)
.field("ExceptionRecord", &self.ExceptionRecord)
.field("ExceptionAddress", &self.ExceptionAddress)
.field("NumberParameters", &self.NumberParameters)
.field("ExceptionInformation", &self.ExceptionInformation)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXCEPTION_RECORD32 {
fn eq(&self, other: &Self) -> bool {
self.ExceptionCode == other.ExceptionCode && self.ExceptionFlags == other.ExceptionFlags && self.ExceptionRecord == other.ExceptionRecord && self.ExceptionAddress == other.ExceptionAddress && self.NumberParameters == other.NumberParameters && self.ExceptionInformation == other.ExceptionInformation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXCEPTION_RECORD32 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXCEPTION_RECORD32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXCEPTION_RECORD64 {
pub ExceptionCode: super::super::super::Foundation::NTSTATUS,
pub ExceptionFlags: u32,
pub ExceptionRecord: u64,
pub ExceptionAddress: u64,
pub NumberParameters: u32,
pub __unusedAlignment: u32,
pub ExceptionInformation: [u64; 15],
}
#[cfg(feature = "Win32_Foundation")]
impl EXCEPTION_RECORD64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXCEPTION_RECORD64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXCEPTION_RECORD64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXCEPTION_RECORD64")
.field("ExceptionCode", &self.ExceptionCode)
.field("ExceptionFlags", &self.ExceptionFlags)
.field("ExceptionRecord", &self.ExceptionRecord)
.field("ExceptionAddress", &self.ExceptionAddress)
.field("NumberParameters", &self.NumberParameters)
.field("__unusedAlignment", &self.__unusedAlignment)
.field("ExceptionInformation", &self.ExceptionInformation)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXCEPTION_RECORD64 {
fn eq(&self, other: &Self) -> bool {
self.ExceptionCode == other.ExceptionCode && self.ExceptionFlags == other.ExceptionFlags && self.ExceptionRecord == other.ExceptionRecord && self.ExceptionAddress == other.ExceptionAddress && self.NumberParameters == other.NumberParameters && self.__unusedAlignment == other.__unusedAlignment && self.ExceptionInformation == other.ExceptionInformation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXCEPTION_RECORD64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXCEPTION_RECORD64 {
type Abi = Self;
}
pub const EXIT_ON_CONTROLC: u32 = 8u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXIT_PROCESS_DEBUG_INFO {
pub dwExitCode: u32,
}
impl EXIT_PROCESS_DEBUG_INFO {}
impl ::core::default::Default for EXIT_PROCESS_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXIT_PROCESS_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXIT_PROCESS_DEBUG_INFO").field("dwExitCode", &self.dwExitCode).finish()
}
}
impl ::core::cmp::PartialEq for EXIT_PROCESS_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.dwExitCode == other.dwExitCode
}
}
impl ::core::cmp::Eq for EXIT_PROCESS_DEBUG_INFO {}
unsafe impl ::windows::core::Abi for EXIT_PROCESS_DEBUG_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXIT_THREAD_DEBUG_INFO {
pub dwExitCode: u32,
}
impl EXIT_THREAD_DEBUG_INFO {}
impl ::core::default::Default for EXIT_THREAD_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXIT_THREAD_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXIT_THREAD_DEBUG_INFO").field("dwExitCode", &self.dwExitCode).finish()
}
}
impl ::core::cmp::PartialEq for EXIT_THREAD_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.dwExitCode == other.dwExitCode
}
}
impl ::core::cmp::Eq for EXIT_THREAD_DEBUG_INFO {}
unsafe impl ::windows::core::Abi for EXIT_THREAD_DEBUG_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXTSTACKTRACE {
pub FramePointer: u32,
pub ProgramCounter: u32,
pub ReturnAddress: u32,
pub Args: [u32; 4],
}
impl EXTSTACKTRACE {}
impl ::core::default::Default for EXTSTACKTRACE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXTSTACKTRACE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXTSTACKTRACE").field("FramePointer", &self.FramePointer).field("ProgramCounter", &self.ProgramCounter).field("ReturnAddress", &self.ReturnAddress).field("Args", &self.Args).finish()
}
}
impl ::core::cmp::PartialEq for EXTSTACKTRACE {
fn eq(&self, other: &Self) -> bool {
self.FramePointer == other.FramePointer && self.ProgramCounter == other.ProgramCounter && self.ReturnAddress == other.ReturnAddress && self.Args == other.Args
}
}
impl ::core::cmp::Eq for EXTSTACKTRACE {}
unsafe impl ::windows::core::Abi for EXTSTACKTRACE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXTSTACKTRACE32 {
pub FramePointer: u32,
pub ProgramCounter: u32,
pub ReturnAddress: u32,
pub Args: [u32; 4],
}
impl EXTSTACKTRACE32 {}
impl ::core::default::Default for EXTSTACKTRACE32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXTSTACKTRACE32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXTSTACKTRACE32").field("FramePointer", &self.FramePointer).field("ProgramCounter", &self.ProgramCounter).field("ReturnAddress", &self.ReturnAddress).field("Args", &self.Args).finish()
}
}
impl ::core::cmp::PartialEq for EXTSTACKTRACE32 {
fn eq(&self, other: &Self) -> bool {
self.FramePointer == other.FramePointer && self.ProgramCounter == other.ProgramCounter && self.ReturnAddress == other.ReturnAddress && self.Args == other.Args
}
}
impl ::core::cmp::Eq for EXTSTACKTRACE32 {}
unsafe impl ::windows::core::Abi for EXTSTACKTRACE32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXTSTACKTRACE64 {
pub FramePointer: u64,
pub ProgramCounter: u64,
pub ReturnAddress: u64,
pub Args: [u64; 4],
}
impl EXTSTACKTRACE64 {}
impl ::core::default::Default for EXTSTACKTRACE64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXTSTACKTRACE64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXTSTACKTRACE64").field("FramePointer", &self.FramePointer).field("ProgramCounter", &self.ProgramCounter).field("ReturnAddress", &self.ReturnAddress).field("Args", &self.Args).finish()
}
}
impl ::core::cmp::PartialEq for EXTSTACKTRACE64 {
fn eq(&self, other: &Self) -> bool {
self.FramePointer == other.FramePointer && self.ProgramCounter == other.ProgramCounter && self.ReturnAddress == other.ReturnAddress && self.Args == other.Args
}
}
impl ::core::cmp::Eq for EXTSTACKTRACE64 {}
unsafe impl ::windows::core::Abi for EXTSTACKTRACE64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXT_API_VERSION {
pub MajorVersion: u16,
pub MinorVersion: u16,
pub Revision: u16,
pub Reserved: u16,
}
impl EXT_API_VERSION {}
impl ::core::default::Default for EXT_API_VERSION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXT_API_VERSION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXT_API_VERSION").field("MajorVersion", &self.MajorVersion).field("MinorVersion", &self.MinorVersion).field("Revision", &self.Revision).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for EXT_API_VERSION {
fn eq(&self, other: &Self) -> bool {
self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion && self.Revision == other.Revision && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for EXT_API_VERSION {}
unsafe impl ::windows::core::Abi for EXT_API_VERSION {
type Abi = Self;
}
pub const EXT_API_VERSION_NUMBER: u32 = 5u32;
pub const EXT_API_VERSION_NUMBER32: u32 = 5u32;
pub const EXT_API_VERSION_NUMBER64: u32 = 6u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXT_FIND_FILE {
pub FileName: super::super::super::Foundation::PWSTR,
pub IndexedSize: u64,
pub ImageTimeDateStamp: u32,
pub ImageCheckSum: u32,
pub ExtraInfo: *mut ::core::ffi::c_void,
pub ExtraInfoSize: u32,
pub Flags: u32,
pub FileMapping: *mut ::core::ffi::c_void,
pub FileMappingSize: u64,
pub FileHandle: super::super::super::Foundation::HANDLE,
pub FoundFileName: super::super::super::Foundation::PWSTR,
pub FoundFileNameChars: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl EXT_FIND_FILE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXT_FIND_FILE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXT_FIND_FILE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXT_FIND_FILE")
.field("FileName", &self.FileName)
.field("IndexedSize", &self.IndexedSize)
.field("ImageTimeDateStamp", &self.ImageTimeDateStamp)
.field("ImageCheckSum", &self.ImageCheckSum)
.field("ExtraInfo", &self.ExtraInfo)
.field("ExtraInfoSize", &self.ExtraInfoSize)
.field("Flags", &self.Flags)
.field("FileMapping", &self.FileMapping)
.field("FileMappingSize", &self.FileMappingSize)
.field("FileHandle", &self.FileHandle)
.field("FoundFileName", &self.FoundFileName)
.field("FoundFileNameChars", &self.FoundFileNameChars)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXT_FIND_FILE {
fn eq(&self, other: &Self) -> bool {
self.FileName == other.FileName
&& self.IndexedSize == other.IndexedSize
&& self.ImageTimeDateStamp == other.ImageTimeDateStamp
&& self.ImageCheckSum == other.ImageCheckSum
&& self.ExtraInfo == other.ExtraInfo
&& self.ExtraInfoSize == other.ExtraInfoSize
&& self.Flags == other.Flags
&& self.FileMapping == other.FileMapping
&& self.FileMappingSize == other.FileMappingSize
&& self.FileHandle == other.FileHandle
&& self.FoundFileName == other.FoundFileName
&& self.FoundFileNameChars == other.FoundFileNameChars
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXT_FIND_FILE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXT_FIND_FILE {
type Abi = Self;
}
pub const EXT_FIND_FILE_ALLOW_GIVEN_PATH: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct EXT_MATCH_PATTERN_A {
pub Str: super::super::super::Foundation::PSTR,
pub Pattern: super::super::super::Foundation::PSTR,
pub CaseSensitive: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl EXT_MATCH_PATTERN_A {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for EXT_MATCH_PATTERN_A {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for EXT_MATCH_PATTERN_A {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXT_MATCH_PATTERN_A").field("Str", &self.Str).field("Pattern", &self.Pattern).field("CaseSensitive", &self.CaseSensitive).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for EXT_MATCH_PATTERN_A {
fn eq(&self, other: &Self) -> bool {
self.Str == other.Str && self.Pattern == other.Pattern && self.CaseSensitive == other.CaseSensitive
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for EXT_MATCH_PATTERN_A {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for EXT_MATCH_PATTERN_A {
type Abi = Self;
}
pub const EXT_OUTPUT_VER: u32 = 1u32;
pub const EXT_TDF_PHYSICAL_CACHED: u32 = 4u32;
pub const EXT_TDF_PHYSICAL_DEFAULT: u32 = 2u32;
pub const EXT_TDF_PHYSICAL_MEMORY: u32 = 14u32;
pub const EXT_TDF_PHYSICAL_UNCACHED: u32 = 6u32;
pub const EXT_TDF_PHYSICAL_WRITE_COMBINED: u32 = 8u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct EXT_TDOP(pub i32);
pub const EXT_TDOP_COPY: EXT_TDOP = EXT_TDOP(0i32);
pub const EXT_TDOP_RELEASE: EXT_TDOP = EXT_TDOP(1i32);
pub const EXT_TDOP_SET_FROM_EXPR: EXT_TDOP = EXT_TDOP(2i32);
pub const EXT_TDOP_SET_FROM_U64_EXPR: EXT_TDOP = EXT_TDOP(3i32);
pub const EXT_TDOP_GET_FIELD: EXT_TDOP = EXT_TDOP(4i32);
pub const EXT_TDOP_EVALUATE: EXT_TDOP = EXT_TDOP(5i32);
pub const EXT_TDOP_GET_TYPE_NAME: EXT_TDOP = EXT_TDOP(6i32);
pub const EXT_TDOP_OUTPUT_TYPE_NAME: EXT_TDOP = EXT_TDOP(7i32);
pub const EXT_TDOP_OUTPUT_SIMPLE_VALUE: EXT_TDOP = EXT_TDOP(8i32);
pub const EXT_TDOP_OUTPUT_FULL_VALUE: EXT_TDOP = EXT_TDOP(9i32);
pub const EXT_TDOP_HAS_FIELD: EXT_TDOP = EXT_TDOP(10i32);
pub const EXT_TDOP_GET_FIELD_OFFSET: EXT_TDOP = EXT_TDOP(11i32);
pub const EXT_TDOP_GET_ARRAY_ELEMENT: EXT_TDOP = EXT_TDOP(12i32);
pub const EXT_TDOP_GET_DEREFERENCE: EXT_TDOP = EXT_TDOP(13i32);
pub const EXT_TDOP_GET_TYPE_SIZE: EXT_TDOP = EXT_TDOP(14i32);
pub const EXT_TDOP_OUTPUT_TYPE_DEFINITION: EXT_TDOP = EXT_TDOP(15i32);
pub const EXT_TDOP_GET_POINTER_TO: EXT_TDOP = EXT_TDOP(16i32);
pub const EXT_TDOP_SET_FROM_TYPE_ID_AND_U64: EXT_TDOP = EXT_TDOP(17i32);
pub const EXT_TDOP_SET_PTR_FROM_TYPE_ID_AND_U64: EXT_TDOP = EXT_TDOP(18i32);
pub const EXT_TDOP_COUNT: EXT_TDOP = EXT_TDOP(19i32);
impl ::core::convert::From<i32> for EXT_TDOP {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for EXT_TDOP {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct EXT_TYPED_DATA {
pub Operation: EXT_TDOP,
pub Flags: u32,
pub InData: DEBUG_TYPED_DATA,
pub OutData: DEBUG_TYPED_DATA,
pub InStrIndex: u32,
pub In32: u32,
pub Out32: u32,
pub In64: u64,
pub Out64: u64,
pub StrBufferIndex: u32,
pub StrBufferChars: u32,
pub StrCharsNeeded: u32,
pub DataBufferIndex: u32,
pub DataBufferBytes: u32,
pub DataBytesNeeded: u32,
pub Status: ::windows::core::HRESULT,
pub Reserved: [u64; 8],
}
impl EXT_TYPED_DATA {}
impl ::core::default::Default for EXT_TYPED_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for EXT_TYPED_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("EXT_TYPED_DATA")
.field("Operation", &self.Operation)
.field("Flags", &self.Flags)
.field("InData", &self.InData)
.field("OutData", &self.OutData)
.field("InStrIndex", &self.InStrIndex)
.field("In32", &self.In32)
.field("Out32", &self.Out32)
.field("In64", &self.In64)
.field("Out64", &self.Out64)
.field("StrBufferIndex", &self.StrBufferIndex)
.field("StrBufferChars", &self.StrBufferChars)
.field("StrCharsNeeded", &self.StrCharsNeeded)
.field("DataBufferIndex", &self.DataBufferIndex)
.field("DataBufferBytes", &self.DataBufferBytes)
.field("DataBytesNeeded", &self.DataBytesNeeded)
.field("Status", &self.Status)
.field("Reserved", &self.Reserved)
.finish()
}
}
impl ::core::cmp::PartialEq for EXT_TYPED_DATA {
fn eq(&self, other: &Self) -> bool {
self.Operation == other.Operation
&& self.Flags == other.Flags
&& self.InData == other.InData
&& self.OutData == other.OutData
&& self.InStrIndex == other.InStrIndex
&& self.In32 == other.In32
&& self.Out32 == other.Out32
&& self.In64 == other.In64
&& self.Out64 == other.Out64
&& self.StrBufferIndex == other.StrBufferIndex
&& self.StrBufferChars == other.StrBufferChars
&& self.StrCharsNeeded == other.StrCharsNeeded
&& self.DataBufferIndex == other.DataBufferIndex
&& self.DataBufferBytes == other.DataBufferBytes
&& self.DataBytesNeeded == other.DataBytesNeeded
&& self.Status == other.Status
&& self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for EXT_TYPED_DATA {}
unsafe impl ::windows::core::Abi for EXT_TYPED_DATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct EX_PROP_INFO_FLAGS(pub i32);
pub const EX_PROP_INFO_ID: EX_PROP_INFO_FLAGS = EX_PROP_INFO_FLAGS(256i32);
pub const EX_PROP_INFO_NTYPE: EX_PROP_INFO_FLAGS = EX_PROP_INFO_FLAGS(512i32);
pub const EX_PROP_INFO_NVALUE: EX_PROP_INFO_FLAGS = EX_PROP_INFO_FLAGS(1024i32);
pub const EX_PROP_INFO_LOCKBYTES: EX_PROP_INFO_FLAGS = EX_PROP_INFO_FLAGS(2048i32);
pub const EX_PROP_INFO_DEBUGEXTPROP: EX_PROP_INFO_FLAGS = EX_PROP_INFO_FLAGS(4096i32);
impl ::core::convert::From<i32> for EX_PROP_INFO_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for EX_PROP_INFO_FLAGS {
type Abi = Self;
}
pub const E_JsDEBUG_INVALID_MEMORY_ADDRESS: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338171i32 as _);
pub const E_JsDEBUG_MISMATCHED_RUNTIME: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338175i32 as _);
pub const E_JsDEBUG_OUTSIDE_OF_VM: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338172i32 as _);
pub const E_JsDEBUG_RUNTIME_NOT_IN_DEBUG_MODE: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338169i32 as _);
pub const E_JsDEBUG_SOURCE_LOCATION_NOT_FOUND: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338170i32 as _);
pub const E_JsDEBUG_UNKNOWN_THREAD: ::windows::core::HRESULT = ::windows::core::HRESULT(-1916338174i32 as _);
#[inline]
pub unsafe fn EncodePointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EncodePointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(EncodePointer(::core::mem::transmute(ptr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EncodeRemotePointer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(processhandle: Param0, ptr: *const ::core::ffi::c_void, encodedptr: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EncodeRemotePointer(processhandle: super::super::super::Foundation::HANDLE, ptr: *const ::core::ffi::c_void, encodedptr: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT;
}
EncodeRemotePointer(processhandle.into_param().abi(), ::core::mem::transmute(ptr), ::core::mem::transmute(encodedptr)).ok()
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn EncodeSystemPointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EncodeSystemPointer(ptr: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(EncodeSystemPointer(::core::mem::transmute(ptr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumDirTree<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
rootpath: Param1,
inputpathname: Param2,
outputpathbuffer: super::super::super::Foundation::PSTR,
cb: ::core::option::Option<PENUMDIRTREE_CALLBACK>,
data: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumDirTree(hprocess: super::super::super::Foundation::HANDLE, rootpath: super::super::super::Foundation::PSTR, inputpathname: super::super::super::Foundation::PSTR, outputpathbuffer: super::super::super::Foundation::PSTR, cb: ::windows::core::RawPtr, data: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumDirTree(hprocess.into_param().abi(), rootpath.into_param().abi(), inputpathname.into_param().abi(), ::core::mem::transmute(outputpathbuffer), ::core::mem::transmute(cb), ::core::mem::transmute(data)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumDirTreeW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
rootpath: Param1,
inputpathname: Param2,
outputpathbuffer: super::super::super::Foundation::PWSTR,
cb: ::core::option::Option<PENUMDIRTREE_CALLBACKW>,
data: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumDirTreeW(hprocess: super::super::super::Foundation::HANDLE, rootpath: super::super::super::Foundation::PWSTR, inputpathname: super::super::super::Foundation::PWSTR, outputpathbuffer: super::super::super::Foundation::PWSTR, cb: ::windows::core::RawPtr, data: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumDirTreeW(hprocess.into_param().abi(), rootpath.into_param().abi(), inputpathname.into_param().abi(), ::core::mem::transmute(outputpathbuffer), ::core::mem::transmute(cb), ::core::mem::transmute(data)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumerateLoadedModules<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enumloadedmodulescallback: ::core::option::Option<PENUMLOADED_MODULES_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumerateLoadedModules(hprocess: super::super::super::Foundation::HANDLE, enumloadedmodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumerateLoadedModules(hprocess.into_param().abi(), ::core::mem::transmute(enumloadedmodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumerateLoadedModules64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enumloadedmodulescallback: ::core::option::Option<PENUMLOADED_MODULES_CALLBACK64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumerateLoadedModules64(hprocess: super::super::super::Foundation::HANDLE, enumloadedmodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumerateLoadedModules64(hprocess.into_param().abi(), ::core::mem::transmute(enumloadedmodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumerateLoadedModulesEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enumloadedmodulescallback: ::core::option::Option<PENUMLOADED_MODULES_CALLBACK64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumerateLoadedModulesEx(hprocess: super::super::super::Foundation::HANDLE, enumloadedmodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumerateLoadedModulesEx(hprocess.into_param().abi(), ::core::mem::transmute(enumloadedmodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumerateLoadedModulesExW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enumloadedmodulescallback: ::core::option::Option<PENUMLOADED_MODULES_CALLBACKW64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumerateLoadedModulesExW(hprocess: super::super::super::Foundation::HANDLE, enumloadedmodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumerateLoadedModulesExW(hprocess.into_param().abi(), ::core::mem::transmute(enumloadedmodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn EnumerateLoadedModulesW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enumloadedmodulescallback: ::core::option::Option<PENUMLOADED_MODULES_CALLBACKW64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn EnumerateLoadedModulesW64(hprocess: super::super::super::Foundation::HANDLE, enumloadedmodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(EnumerateLoadedModulesW64(hprocess.into_param().abi(), ::core::mem::transmute(enumloadedmodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ErrorClass(pub i32);
pub const ErrorClassWarning: ErrorClass = ErrorClass(0i32);
pub const ErrorClassError: ErrorClass = ErrorClass(1i32);
impl ::core::convert::From<i32> for ErrorClass {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ErrorClass {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
impl ::core::clone::Clone for ExtendedDebugPropertyInfo {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
pub struct ExtendedDebugPropertyInfo {
pub dwValidFields: u32,
pub pszName: super::super::super::Foundation::PWSTR,
pub pszType: super::super::super::Foundation::PWSTR,
pub pszValue: super::super::super::Foundation::PWSTR,
pub pszFullName: super::super::super::Foundation::PWSTR,
pub dwAttrib: u32,
pub pDebugProp: ::core::option::Option<IDebugProperty>,
pub nDISPID: u32,
pub nType: u32,
pub varValue: super::super::Com::VARIANT,
pub plbValue: ::core::option::Option<super::super::Com::StructuredStorage::ILockBytes>,
pub pDebugExtProp: ::core::option::Option<IDebugExtendedProperty>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
impl ExtendedDebugPropertyInfo {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
impl ::core::default::Default for ExtendedDebugPropertyInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for ExtendedDebugPropertyInfo {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for ExtendedDebugPropertyInfo {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for ExtendedDebugPropertyInfo {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct FACILITY_CODE(pub u32);
pub const FACILITY_NULL: FACILITY_CODE = FACILITY_CODE(0u32);
pub const FACILITY_RPC: FACILITY_CODE = FACILITY_CODE(1u32);
pub const FACILITY_DISPATCH: FACILITY_CODE = FACILITY_CODE(2u32);
pub const FACILITY_STORAGE: FACILITY_CODE = FACILITY_CODE(3u32);
pub const FACILITY_ITF: FACILITY_CODE = FACILITY_CODE(4u32);
pub const FACILITY_WIN32: FACILITY_CODE = FACILITY_CODE(7u32);
pub const FACILITY_WINDOWS: FACILITY_CODE = FACILITY_CODE(8u32);
pub const FACILITY_SSPI: FACILITY_CODE = FACILITY_CODE(9u32);
pub const FACILITY_SECURITY: FACILITY_CODE = FACILITY_CODE(9u32);
pub const FACILITY_CONTROL: FACILITY_CODE = FACILITY_CODE(10u32);
pub const FACILITY_CERT: FACILITY_CODE = FACILITY_CODE(11u32);
pub const FACILITY_INTERNET: FACILITY_CODE = FACILITY_CODE(12u32);
pub const FACILITY_MEDIASERVER: FACILITY_CODE = FACILITY_CODE(13u32);
pub const FACILITY_MSMQ: FACILITY_CODE = FACILITY_CODE(14u32);
pub const FACILITY_SETUPAPI: FACILITY_CODE = FACILITY_CODE(15u32);
pub const FACILITY_SCARD: FACILITY_CODE = FACILITY_CODE(16u32);
pub const FACILITY_COMPLUS: FACILITY_CODE = FACILITY_CODE(17u32);
pub const FACILITY_AAF: FACILITY_CODE = FACILITY_CODE(18u32);
pub const FACILITY_URT: FACILITY_CODE = FACILITY_CODE(19u32);
pub const FACILITY_ACS: FACILITY_CODE = FACILITY_CODE(20u32);
pub const FACILITY_DPLAY: FACILITY_CODE = FACILITY_CODE(21u32);
pub const FACILITY_UMI: FACILITY_CODE = FACILITY_CODE(22u32);
pub const FACILITY_SXS: FACILITY_CODE = FACILITY_CODE(23u32);
pub const FACILITY_WINDOWS_CE: FACILITY_CODE = FACILITY_CODE(24u32);
pub const FACILITY_HTTP: FACILITY_CODE = FACILITY_CODE(25u32);
pub const FACILITY_USERMODE_COMMONLOG: FACILITY_CODE = FACILITY_CODE(26u32);
pub const FACILITY_WER: FACILITY_CODE = FACILITY_CODE(27u32);
pub const FACILITY_USERMODE_FILTER_MANAGER: FACILITY_CODE = FACILITY_CODE(31u32);
pub const FACILITY_BACKGROUNDCOPY: FACILITY_CODE = FACILITY_CODE(32u32);
pub const FACILITY_CONFIGURATION: FACILITY_CODE = FACILITY_CODE(33u32);
pub const FACILITY_WIA: FACILITY_CODE = FACILITY_CODE(33u32);
pub const FACILITY_STATE_MANAGEMENT: FACILITY_CODE = FACILITY_CODE(34u32);
pub const FACILITY_METADIRECTORY: FACILITY_CODE = FACILITY_CODE(35u32);
pub const FACILITY_WINDOWSUPDATE: FACILITY_CODE = FACILITY_CODE(36u32);
pub const FACILITY_DIRECTORYSERVICE: FACILITY_CODE = FACILITY_CODE(37u32);
pub const FACILITY_GRAPHICS: FACILITY_CODE = FACILITY_CODE(38u32);
pub const FACILITY_SHELL: FACILITY_CODE = FACILITY_CODE(39u32);
pub const FACILITY_NAP: FACILITY_CODE = FACILITY_CODE(39u32);
pub const FACILITY_TPM_SERVICES: FACILITY_CODE = FACILITY_CODE(40u32);
pub const FACILITY_TPM_SOFTWARE: FACILITY_CODE = FACILITY_CODE(41u32);
pub const FACILITY_UI: FACILITY_CODE = FACILITY_CODE(42u32);
pub const FACILITY_XAML: FACILITY_CODE = FACILITY_CODE(43u32);
pub const FACILITY_ACTION_QUEUE: FACILITY_CODE = FACILITY_CODE(44u32);
pub const FACILITY_PLA: FACILITY_CODE = FACILITY_CODE(48u32);
pub const FACILITY_WINDOWS_SETUP: FACILITY_CODE = FACILITY_CODE(48u32);
pub const FACILITY_FVE: FACILITY_CODE = FACILITY_CODE(49u32);
pub const FACILITY_FWP: FACILITY_CODE = FACILITY_CODE(50u32);
pub const FACILITY_WINRM: FACILITY_CODE = FACILITY_CODE(51u32);
pub const FACILITY_NDIS: FACILITY_CODE = FACILITY_CODE(52u32);
pub const FACILITY_USERMODE_HYPERVISOR: FACILITY_CODE = FACILITY_CODE(53u32);
pub const FACILITY_CMI: FACILITY_CODE = FACILITY_CODE(54u32);
pub const FACILITY_USERMODE_VIRTUALIZATION: FACILITY_CODE = FACILITY_CODE(55u32);
pub const FACILITY_USERMODE_VOLMGR: FACILITY_CODE = FACILITY_CODE(56u32);
pub const FACILITY_BCD: FACILITY_CODE = FACILITY_CODE(57u32);
pub const FACILITY_USERMODE_VHD: FACILITY_CODE = FACILITY_CODE(58u32);
pub const FACILITY_USERMODE_HNS: FACILITY_CODE = FACILITY_CODE(59u32);
pub const FACILITY_SDIAG: FACILITY_CODE = FACILITY_CODE(60u32);
pub const FACILITY_WEBSERVICES: FACILITY_CODE = FACILITY_CODE(61u32);
pub const FACILITY_WINPE: FACILITY_CODE = FACILITY_CODE(61u32);
pub const FACILITY_WPN: FACILITY_CODE = FACILITY_CODE(62u32);
pub const FACILITY_WINDOWS_STORE: FACILITY_CODE = FACILITY_CODE(63u32);
pub const FACILITY_INPUT: FACILITY_CODE = FACILITY_CODE(64u32);
pub const FACILITY_QUIC: FACILITY_CODE = FACILITY_CODE(65u32);
pub const FACILITY_EAP: FACILITY_CODE = FACILITY_CODE(66u32);
pub const FACILITY_IORING: FACILITY_CODE = FACILITY_CODE(70u32);
pub const FACILITY_WINDOWS_DEFENDER: FACILITY_CODE = FACILITY_CODE(80u32);
pub const FACILITY_OPC: FACILITY_CODE = FACILITY_CODE(81u32);
pub const FACILITY_XPS: FACILITY_CODE = FACILITY_CODE(82u32);
pub const FACILITY_MBN: FACILITY_CODE = FACILITY_CODE(84u32);
pub const FACILITY_POWERSHELL: FACILITY_CODE = FACILITY_CODE(84u32);
pub const FACILITY_RAS: FACILITY_CODE = FACILITY_CODE(83u32);
pub const FACILITY_P2P_INT: FACILITY_CODE = FACILITY_CODE(98u32);
pub const FACILITY_P2P: FACILITY_CODE = FACILITY_CODE(99u32);
pub const FACILITY_DAF: FACILITY_CODE = FACILITY_CODE(100u32);
pub const FACILITY_BLUETOOTH_ATT: FACILITY_CODE = FACILITY_CODE(101u32);
pub const FACILITY_AUDIO: FACILITY_CODE = FACILITY_CODE(102u32);
pub const FACILITY_STATEREPOSITORY: FACILITY_CODE = FACILITY_CODE(103u32);
pub const FACILITY_VISUALCPP: FACILITY_CODE = FACILITY_CODE(109u32);
pub const FACILITY_SCRIPT: FACILITY_CODE = FACILITY_CODE(112u32);
pub const FACILITY_PARSE: FACILITY_CODE = FACILITY_CODE(113u32);
pub const FACILITY_BLB: FACILITY_CODE = FACILITY_CODE(120u32);
pub const FACILITY_BLB_CLI: FACILITY_CODE = FACILITY_CODE(121u32);
pub const FACILITY_WSBAPP: FACILITY_CODE = FACILITY_CODE(122u32);
pub const FACILITY_BLBUI: FACILITY_CODE = FACILITY_CODE(128u32);
pub const FACILITY_USN: FACILITY_CODE = FACILITY_CODE(129u32);
pub const FACILITY_USERMODE_VOLSNAP: FACILITY_CODE = FACILITY_CODE(130u32);
pub const FACILITY_TIERING: FACILITY_CODE = FACILITY_CODE(131u32);
pub const FACILITY_WSB_ONLINE: FACILITY_CODE = FACILITY_CODE(133u32);
pub const FACILITY_ONLINE_ID: FACILITY_CODE = FACILITY_CODE(134u32);
pub const FACILITY_DEVICE_UPDATE_AGENT: FACILITY_CODE = FACILITY_CODE(135u32);
pub const FACILITY_DRVSERVICING: FACILITY_CODE = FACILITY_CODE(136u32);
pub const FACILITY_DLS: FACILITY_CODE = FACILITY_CODE(153u32);
pub const FACILITY_DELIVERY_OPTIMIZATION: FACILITY_CODE = FACILITY_CODE(208u32);
pub const FACILITY_USERMODE_SPACES: FACILITY_CODE = FACILITY_CODE(231u32);
pub const FACILITY_USER_MODE_SECURITY_CORE: FACILITY_CODE = FACILITY_CODE(232u32);
pub const FACILITY_USERMODE_LICENSING: FACILITY_CODE = FACILITY_CODE(234u32);
pub const FACILITY_SOS: FACILITY_CODE = FACILITY_CODE(160u32);
pub const FACILITY_OCP_UPDATE_AGENT: FACILITY_CODE = FACILITY_CODE(173u32);
pub const FACILITY_DEBUGGERS: FACILITY_CODE = FACILITY_CODE(176u32);
pub const FACILITY_SPP: FACILITY_CODE = FACILITY_CODE(256u32);
pub const FACILITY_RESTORE: FACILITY_CODE = FACILITY_CODE(256u32);
pub const FACILITY_DMSERVER: FACILITY_CODE = FACILITY_CODE(256u32);
pub const FACILITY_DEPLOYMENT_SERVICES_SERVER: FACILITY_CODE = FACILITY_CODE(257u32);
pub const FACILITY_DEPLOYMENT_SERVICES_IMAGING: FACILITY_CODE = FACILITY_CODE(258u32);
pub const FACILITY_DEPLOYMENT_SERVICES_MANAGEMENT: FACILITY_CODE = FACILITY_CODE(259u32);
pub const FACILITY_DEPLOYMENT_SERVICES_UTIL: FACILITY_CODE = FACILITY_CODE(260u32);
pub const FACILITY_DEPLOYMENT_SERVICES_BINLSVC: FACILITY_CODE = FACILITY_CODE(261u32);
pub const FACILITY_DEPLOYMENT_SERVICES_PXE: FACILITY_CODE = FACILITY_CODE(263u32);
pub const FACILITY_DEPLOYMENT_SERVICES_TFTP: FACILITY_CODE = FACILITY_CODE(264u32);
pub const FACILITY_DEPLOYMENT_SERVICES_TRANSPORT_MANAGEMENT: FACILITY_CODE = FACILITY_CODE(272u32);
pub const FACILITY_DEPLOYMENT_SERVICES_DRIVER_PROVISIONING: FACILITY_CODE = FACILITY_CODE(278u32);
pub const FACILITY_DEPLOYMENT_SERVICES_MULTICAST_SERVER: FACILITY_CODE = FACILITY_CODE(289u32);
pub const FACILITY_DEPLOYMENT_SERVICES_MULTICAST_CLIENT: FACILITY_CODE = FACILITY_CODE(290u32);
pub const FACILITY_DEPLOYMENT_SERVICES_CONTENT_PROVIDER: FACILITY_CODE = FACILITY_CODE(293u32);
pub const FACILITY_HSP_SERVICES: FACILITY_CODE = FACILITY_CODE(296u32);
pub const FACILITY_HSP_SOFTWARE: FACILITY_CODE = FACILITY_CODE(297u32);
pub const FACILITY_LINGUISTIC_SERVICES: FACILITY_CODE = FACILITY_CODE(305u32);
pub const FACILITY_AUDIOSTREAMING: FACILITY_CODE = FACILITY_CODE(1094u32);
pub const FACILITY_TTD: FACILITY_CODE = FACILITY_CODE(1490u32);
pub const FACILITY_ACCELERATOR: FACILITY_CODE = FACILITY_CODE(1536u32);
pub const FACILITY_WMAAECMA: FACILITY_CODE = FACILITY_CODE(1996u32);
pub const FACILITY_DIRECTMUSIC: FACILITY_CODE = FACILITY_CODE(2168u32);
pub const FACILITY_DIRECT3D10: FACILITY_CODE = FACILITY_CODE(2169u32);
pub const FACILITY_DXGI: FACILITY_CODE = FACILITY_CODE(2170u32);
pub const FACILITY_DXGI_DDI: FACILITY_CODE = FACILITY_CODE(2171u32);
pub const FACILITY_DIRECT3D11: FACILITY_CODE = FACILITY_CODE(2172u32);
pub const FACILITY_DIRECT3D11_DEBUG: FACILITY_CODE = FACILITY_CODE(2173u32);
pub const FACILITY_DIRECT3D12: FACILITY_CODE = FACILITY_CODE(2174u32);
pub const FACILITY_DIRECT3D12_DEBUG: FACILITY_CODE = FACILITY_CODE(2175u32);
pub const FACILITY_DXCORE: FACILITY_CODE = FACILITY_CODE(2176u32);
pub const FACILITY_PRESENTATION: FACILITY_CODE = FACILITY_CODE(2177u32);
pub const FACILITY_LEAP: FACILITY_CODE = FACILITY_CODE(2184u32);
pub const FACILITY_AUDCLNT: FACILITY_CODE = FACILITY_CODE(2185u32);
pub const FACILITY_WINCODEC_DWRITE_DWM: FACILITY_CODE = FACILITY_CODE(2200u32);
pub const FACILITY_WINML: FACILITY_CODE = FACILITY_CODE(2192u32);
pub const FACILITY_DIRECT2D: FACILITY_CODE = FACILITY_CODE(2201u32);
pub const FACILITY_DEFRAG: FACILITY_CODE = FACILITY_CODE(2304u32);
pub const FACILITY_USERMODE_SDBUS: FACILITY_CODE = FACILITY_CODE(2305u32);
pub const FACILITY_JSCRIPT: FACILITY_CODE = FACILITY_CODE(2306u32);
pub const FACILITY_PIDGENX: FACILITY_CODE = FACILITY_CODE(2561u32);
pub const FACILITY_EAS: FACILITY_CODE = FACILITY_CODE(85u32);
pub const FACILITY_WEB: FACILITY_CODE = FACILITY_CODE(885u32);
pub const FACILITY_WEB_SOCKET: FACILITY_CODE = FACILITY_CODE(886u32);
pub const FACILITY_MOBILE: FACILITY_CODE = FACILITY_CODE(1793u32);
pub const FACILITY_SQLITE: FACILITY_CODE = FACILITY_CODE(1967u32);
pub const FACILITY_SERVICE_FABRIC: FACILITY_CODE = FACILITY_CODE(1968u32);
pub const FACILITY_UTC: FACILITY_CODE = FACILITY_CODE(1989u32);
pub const FACILITY_WEP: FACILITY_CODE = FACILITY_CODE(2049u32);
pub const FACILITY_SYNCENGINE: FACILITY_CODE = FACILITY_CODE(2050u32);
pub const FACILITY_XBOX: FACILITY_CODE = FACILITY_CODE(2339u32);
pub const FACILITY_GAME: FACILITY_CODE = FACILITY_CODE(2340u32);
pub const FACILITY_PIX: FACILITY_CODE = FACILITY_CODE(2748u32);
pub const FACILITY_NT_BIT: FACILITY_CODE = FACILITY_CODE(268435456u32);
impl ::core::convert::From<u32> for FACILITY_CODE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for FACILITY_CODE {
type Abi = Self;
}
impl ::core::ops::BitOr for FACILITY_CODE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for FACILITY_CODE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for FACILITY_CODE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for FACILITY_CODE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for FACILITY_CODE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const FACILITY_JsDEBUG: u32 = 3527u32;
pub const FIELDS_DID_NOT_MATCH: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct FIELD_INFO {
pub fName: *mut u8,
pub printName: *mut u8,
pub size: u32,
pub fOptions: u32,
pub address: u64,
pub Anonymous: FIELD_INFO_0,
pub TypeId: u32,
pub FieldOffset: u32,
pub BufferSize: u32,
pub BitField: FIELD_INFO_1,
pub _bitfield: u32,
}
impl FIELD_INFO {}
impl ::core::default::Default for FIELD_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for FIELD_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for FIELD_INFO {}
unsafe impl ::windows::core::Abi for FIELD_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union FIELD_INFO_0 {
pub fieldCallBack: *mut ::core::ffi::c_void,
pub pBuffer: *mut ::core::ffi::c_void,
}
impl FIELD_INFO_0 {}
impl ::core::default::Default for FIELD_INFO_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for FIELD_INFO_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for FIELD_INFO_0 {}
unsafe impl ::windows::core::Abi for FIELD_INFO_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct FIELD_INFO_1 {
pub Position: u16,
pub Size: u16,
}
impl FIELD_INFO_1 {}
impl ::core::default::Default for FIELD_INFO_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for FIELD_INFO_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_BitField").field("Position", &self.Position).field("Size", &self.Size).finish()
}
}
impl ::core::cmp::PartialEq for FIELD_INFO_1 {
fn eq(&self, other: &Self) -> bool {
self.Position == other.Position && self.Size == other.Size
}
}
impl ::core::cmp::Eq for FIELD_INFO_1 {}
unsafe impl ::windows::core::Abi for FIELD_INFO_1 {
type Abi = Self;
}
pub const FLAG_ENGINE_PRESENT: u32 = 4u32;
pub const FLAG_ENGOPT_DISALLOW_NETWORK_PATHS: u32 = 8u32;
pub const FLAG_OVERRIDE_ARM_MACHINE_TYPE: u32 = 16u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct FORMAT_MESSAGE_OPTIONS(pub u32);
pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(256u32);
pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(8192u32);
pub const FORMAT_MESSAGE_FROM_HMODULE: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(2048u32);
pub const FORMAT_MESSAGE_FROM_STRING: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(1024u32);
pub const FORMAT_MESSAGE_FROM_SYSTEM: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(4096u32);
pub const FORMAT_MESSAGE_IGNORE_INSERTS: FORMAT_MESSAGE_OPTIONS = FORMAT_MESSAGE_OPTIONS(512u32);
impl ::core::convert::From<u32> for FORMAT_MESSAGE_OPTIONS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for FORMAT_MESSAGE_OPTIONS {
type Abi = Self;
}
impl ::core::ops::BitOr for FORMAT_MESSAGE_OPTIONS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for FORMAT_MESSAGE_OPTIONS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for FORMAT_MESSAGE_OPTIONS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for FORMAT_MESSAGE_OPTIONS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for FORMAT_MESSAGE_OPTIONS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct FPO_DATA {
pub ulOffStart: u32,
pub cbProcSize: u32,
pub cdwLocals: u32,
pub cdwParams: u16,
pub _bitfield: u16,
}
impl FPO_DATA {}
impl ::core::default::Default for FPO_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for FPO_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("FPO_DATA").field("ulOffStart", &self.ulOffStart).field("cbProcSize", &self.cbProcSize).field("cdwLocals", &self.cdwLocals).field("cdwParams", &self.cdwParams).field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for FPO_DATA {
fn eq(&self, other: &Self) -> bool {
self.ulOffStart == other.ulOffStart && self.cbProcSize == other.cbProcSize && self.cdwLocals == other.cdwLocals && self.cdwParams == other.cdwParams && self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for FPO_DATA {}
unsafe impl ::windows::core::Abi for FPO_DATA {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FatalAppExitA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(uaction: u32, lpmessagetext: Param1) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FatalAppExitA(uaction: u32, lpmessagetext: super::super::super::Foundation::PSTR);
}
::core::mem::transmute(FatalAppExitA(::core::mem::transmute(uaction), lpmessagetext.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FatalAppExitW<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(uaction: u32, lpmessagetext: Param1) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FatalAppExitW(uaction: u32, lpmessagetext: super::super::super::Foundation::PWSTR);
}
::core::mem::transmute(FatalAppExitW(::core::mem::transmute(uaction), lpmessagetext.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn FatalExit(exitcode: i32) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FatalExit(exitcode: i32);
}
::core::mem::transmute(FatalExit(::core::mem::transmute(exitcode)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindDebugInfoFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, symbolpath: Param1, debugfilepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindDebugInfoFile(filename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, debugfilepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindDebugInfoFile(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(debugfilepath)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindDebugInfoFileEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, symbolpath: Param1, debugfilepath: super::super::super::Foundation::PSTR, callback: ::core::option::Option<PFIND_DEBUG_FILE_CALLBACK>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindDebugInfoFileEx(filename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, debugfilepath: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindDebugInfoFileEx(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindDebugInfoFileExW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(filename: Param0, symbolpath: Param1, debugfilepath: super::super::super::Foundation::PWSTR, callback: ::core::option::Option<PFIND_DEBUG_FILE_CALLBACKW>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindDebugInfoFileExW(filename: super::super::super::Foundation::PWSTR, symbolpath: super::super::super::Foundation::PWSTR, debugfilepath: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindDebugInfoFileExW(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindExecutableImage<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, symbolpath: Param1, imagefilepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindExecutableImage(filename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, imagefilepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindExecutableImage(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(imagefilepath)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindExecutableImageEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, symbolpath: Param1, imagefilepath: super::super::super::Foundation::PSTR, callback: ::core::option::Option<PFIND_EXE_FILE_CALLBACK>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindExecutableImageEx(filename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, imagefilepath: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindExecutableImageEx(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(imagefilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindExecutableImageExW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(filename: Param0, symbolpath: Param1, imagefilepath: super::super::super::Foundation::PWSTR, callback: ::core::option::Option<PFIND_EXE_FILE_CALLBACKW>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindExecutableImageExW(filename: super::super::super::Foundation::PWSTR, symbolpath: super::super::super::Foundation::PWSTR, imagefilepath: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(FindExecutableImageExW(filename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(imagefilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindFileInPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, searchpatha: Param1, filename: Param2, id: *const ::core::ffi::c_void, two: u32, three: u32, flags: u32, filepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindFileInPath(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, id: *const ::core::ffi::c_void, two: u32, three: u32, flags: u32, filepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(FindFileInPath(hprocess.into_param().abi(), searchpatha.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(id), ::core::mem::transmute(two), ::core::mem::transmute(three), ::core::mem::transmute(flags), ::core::mem::transmute(filepath)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FindFileInSearchPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, searchpatha: Param1, filename: Param2, one: u32, two: u32, three: u32, filepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FindFileInSearchPath(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, one: u32, two: u32, three: u32, filepath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(FindFileInSearchPath(hprocess.into_param().abi(), searchpatha.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(one), ::core::mem::transmute(two), ::core::mem::transmute(three), ::core::mem::transmute(filepath)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FlushInstructionCache<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, lpbaseaddress: *const ::core::ffi::c_void, dwsize: usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FlushInstructionCache(hprocess: super::super::super::Foundation::HANDLE, lpbaseaddress: *const ::core::ffi::c_void, dwsize: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(FlushInstructionCache(hprocess.into_param().abi(), ::core::mem::transmute(lpbaseaddress), ::core::mem::transmute(dwsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FormatMessageA(dwflags: FORMAT_MESSAGE_OPTIONS, lpsource: *const ::core::ffi::c_void, dwmessageid: u32, dwlanguageid: u32, lpbuffer: super::super::super::Foundation::PSTR, nsize: u32, arguments: *const *const i8) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FormatMessageA(dwflags: FORMAT_MESSAGE_OPTIONS, lpsource: *const ::core::ffi::c_void, dwmessageid: u32, dwlanguageid: u32, lpbuffer: super::super::super::Foundation::PSTR, nsize: u32, arguments: *const *const i8) -> u32;
}
::core::mem::transmute(FormatMessageA(::core::mem::transmute(dwflags), ::core::mem::transmute(lpsource), ::core::mem::transmute(dwmessageid), ::core::mem::transmute(dwlanguageid), ::core::mem::transmute(lpbuffer), ::core::mem::transmute(nsize), ::core::mem::transmute(arguments)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn FormatMessageW(dwflags: FORMAT_MESSAGE_OPTIONS, lpsource: *const ::core::ffi::c_void, dwmessageid: u32, dwlanguageid: u32, lpbuffer: super::super::super::Foundation::PWSTR, nsize: u32, arguments: *const *const i8) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn FormatMessageW(dwflags: FORMAT_MESSAGE_OPTIONS, lpsource: *const ::core::ffi::c_void, dwmessageid: u32, dwlanguageid: u32, lpbuffer: super::super::super::Foundation::PWSTR, nsize: u32, arguments: *const *const i8) -> u32;
}
::core::mem::transmute(FormatMessageW(::core::mem::transmute(dwflags), ::core::mem::transmute(lpsource), ::core::mem::transmute(dwmessageid), ::core::mem::transmute(dwlanguageid), ::core::mem::transmute(lpbuffer), ::core::mem::transmute(nsize), ::core::mem::transmute(arguments)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub const GETATTRFLAG_HUMANTEXT: u32 = 32768u32;
pub const GETATTRFLAG_THIS: u32 = 256u32;
pub const GETATTRTYPE_DEPSCAN: u32 = 1u32;
pub const GETATTRTYPE_NORMAL: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct GET_CONTEXT_EX {
pub Status: u32,
pub ContextSize: u32,
pub pContext: *mut ::core::ffi::c_void,
}
impl GET_CONTEXT_EX {}
impl ::core::default::Default for GET_CONTEXT_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for GET_CONTEXT_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_CONTEXT_EX").field("Status", &self.Status).field("ContextSize", &self.ContextSize).field("pContext", &self.pContext).finish()
}
}
impl ::core::cmp::PartialEq for GET_CONTEXT_EX {
fn eq(&self, other: &Self) -> bool {
self.Status == other.Status && self.ContextSize == other.ContextSize && self.pContext == other.pContext
}
}
impl ::core::cmp::Eq for GET_CONTEXT_EX {}
unsafe impl ::windows::core::Abi for GET_CONTEXT_EX {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct GET_CURRENT_PROCESS_ADDRESS {
pub Processor: u32,
pub CurrentThread: u64,
pub Address: u64,
}
impl GET_CURRENT_PROCESS_ADDRESS {}
impl ::core::default::Default for GET_CURRENT_PROCESS_ADDRESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for GET_CURRENT_PROCESS_ADDRESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_CURRENT_PROCESS_ADDRESS").field("Processor", &self.Processor).field("CurrentThread", &self.CurrentThread).field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for GET_CURRENT_PROCESS_ADDRESS {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.CurrentThread == other.CurrentThread && self.Address == other.Address
}
}
impl ::core::cmp::Eq for GET_CURRENT_PROCESS_ADDRESS {}
unsafe impl ::windows::core::Abi for GET_CURRENT_PROCESS_ADDRESS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct GET_CURRENT_THREAD_ADDRESS {
pub Processor: u32,
pub Address: u64,
}
impl GET_CURRENT_THREAD_ADDRESS {}
impl ::core::default::Default for GET_CURRENT_THREAD_ADDRESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for GET_CURRENT_THREAD_ADDRESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_CURRENT_THREAD_ADDRESS").field("Processor", &self.Processor).field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for GET_CURRENT_THREAD_ADDRESS {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.Address == other.Address
}
}
impl ::core::cmp::Eq for GET_CURRENT_THREAD_ADDRESS {}
unsafe impl ::windows::core::Abi for GET_CURRENT_THREAD_ADDRESS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct GET_EXPRESSION_EX {
pub Expression: super::super::super::Foundation::PSTR,
pub Remainder: super::super::super::Foundation::PSTR,
pub Value: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl GET_EXPRESSION_EX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for GET_EXPRESSION_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for GET_EXPRESSION_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_EXPRESSION_EX").field("Expression", &self.Expression).field("Remainder", &self.Remainder).field("Value", &self.Value).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for GET_EXPRESSION_EX {
fn eq(&self, other: &Self) -> bool {
self.Expression == other.Expression && self.Remainder == other.Remainder && self.Value == other.Value
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for GET_EXPRESSION_EX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for GET_EXPRESSION_EX {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct GET_INPUT_LINE {
pub Prompt: super::super::super::Foundation::PSTR,
pub Buffer: super::super::super::Foundation::PSTR,
pub BufferSize: u32,
pub InputSize: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl GET_INPUT_LINE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for GET_INPUT_LINE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for GET_INPUT_LINE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_INPUT_LINE").field("Prompt", &self.Prompt).field("Buffer", &self.Buffer).field("BufferSize", &self.BufferSize).field("InputSize", &self.InputSize).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for GET_INPUT_LINE {
fn eq(&self, other: &Self) -> bool {
self.Prompt == other.Prompt && self.Buffer == other.Buffer && self.BufferSize == other.BufferSize && self.InputSize == other.InputSize
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for GET_INPUT_LINE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for GET_INPUT_LINE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct GET_PEB_ADDRESS {
pub CurrentThread: u64,
pub Address: u64,
}
impl GET_PEB_ADDRESS {}
impl ::core::default::Default for GET_PEB_ADDRESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for GET_PEB_ADDRESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_PEB_ADDRESS").field("CurrentThread", &self.CurrentThread).field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for GET_PEB_ADDRESS {
fn eq(&self, other: &Self) -> bool {
self.CurrentThread == other.CurrentThread && self.Address == other.Address
}
}
impl ::core::cmp::Eq for GET_PEB_ADDRESS {}
unsafe impl ::windows::core::Abi for GET_PEB_ADDRESS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct GET_SET_SYMPATH {
pub Args: super::super::super::Foundation::PSTR,
pub Result: super::super::super::Foundation::PSTR,
pub Length: i32,
}
#[cfg(feature = "Win32_Foundation")]
impl GET_SET_SYMPATH {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for GET_SET_SYMPATH {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for GET_SET_SYMPATH {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_SET_SYMPATH").field("Args", &self.Args).field("Result", &self.Result).field("Length", &self.Length).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for GET_SET_SYMPATH {
fn eq(&self, other: &Self) -> bool {
self.Args == other.Args && self.Result == other.Result && self.Length == other.Length
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for GET_SET_SYMPATH {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for GET_SET_SYMPATH {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct GET_TEB_ADDRESS {
pub Address: u64,
}
impl GET_TEB_ADDRESS {}
impl ::core::default::Default for GET_TEB_ADDRESS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for GET_TEB_ADDRESS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("GET_TEB_ADDRESS").field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for GET_TEB_ADDRESS {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address
}
}
impl ::core::cmp::Eq for GET_TEB_ADDRESS {}
unsafe impl ::windows::core::Abi for GET_TEB_ADDRESS {
type Abi = Self;
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
#[inline]
pub unsafe fn GetEnabledXStateFeatures() -> u64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetEnabledXStateFeatures() -> u64;
}
::core::mem::transmute(GetEnabledXStateFeatures())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn GetErrorMode() -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetErrorMode() -> u32;
}
::core::mem::transmute(GetErrorMode())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn GetImageConfigInformation(loadedimage: *const LOADED_IMAGE, imageconfiginformation: *mut IMAGE_LOAD_CONFIG_DIRECTORY64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetImageConfigInformation(loadedimage: *const LOADED_IMAGE, imageconfiginformation: *mut IMAGE_LOAD_CONFIG_DIRECTORY64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetImageConfigInformation(::core::mem::transmute(loadedimage), ::core::mem::transmute(imageconfiginformation)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn GetImageConfigInformation(loadedimage: *const LOADED_IMAGE, imageconfiginformation: *mut IMAGE_LOAD_CONFIG_DIRECTORY32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetImageConfigInformation(loadedimage: *const LOADED_IMAGE, imageconfiginformation: *mut IMAGE_LOAD_CONFIG_DIRECTORY32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetImageConfigInformation(::core::mem::transmute(loadedimage), ::core::mem::transmute(imageconfiginformation)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn GetImageUnusedHeaderBytes(loadedimage: *const LOADED_IMAGE, sizeunusedheaderbytes: *mut u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetImageUnusedHeaderBytes(loadedimage: *const LOADED_IMAGE, sizeunusedheaderbytes: *mut u32) -> u32;
}
::core::mem::transmute(GetImageUnusedHeaderBytes(::core::mem::transmute(loadedimage), ::core::mem::transmute(sizeunusedheaderbytes)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn GetSymLoadError() -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetSymLoadError() -> u32;
}
::core::mem::transmute(GetSymLoadError())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn GetThreadContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, lpcontext: *mut CONTEXT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetThreadContext(hthread: super::super::super::Foundation::HANDLE, lpcontext: *mut CONTEXT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetThreadContext(hthread.into_param().abi(), ::core::mem::transmute(lpcontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn GetThreadErrorMode() -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetThreadErrorMode() -> u32;
}
::core::mem::transmute(GetThreadErrorMode())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn GetThreadSelectorEntry<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, dwselector: u32, lpselectorentry: *mut LDT_ENTRY) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetThreadSelectorEntry(hthread: super::super::super::Foundation::HANDLE, dwselector: u32, lpselectorentry: *mut LDT_ENTRY) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetThreadSelectorEntry(hthread.into_param().abi(), ::core::mem::transmute(dwselector), ::core::mem::transmute(lpselectorentry)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn GetThreadWaitChain(wcthandle: *const ::core::ffi::c_void, context: usize, flags: WAIT_CHAIN_THREAD_OPTIONS, threadid: u32, nodecount: *mut u32, nodeinfoarray: *mut WAITCHAIN_NODE_INFO, iscycle: *mut i32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetThreadWaitChain(wcthandle: *const ::core::ffi::c_void, context: usize, flags: WAIT_CHAIN_THREAD_OPTIONS, threadid: u32, nodecount: *mut u32, nodeinfoarray: *mut WAITCHAIN_NODE_INFO, iscycle: *mut i32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetThreadWaitChain(::core::mem::transmute(wcthandle), ::core::mem::transmute(context), ::core::mem::transmute(flags), ::core::mem::transmute(threadid), ::core::mem::transmute(nodecount), ::core::mem::transmute(nodeinfoarray), ::core::mem::transmute(iscycle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn GetTimestampForLoadedLibrary<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HINSTANCE>>(module: Param0) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetTimestampForLoadedLibrary(module: super::super::super::Foundation::HINSTANCE) -> u32;
}
::core::mem::transmute(GetTimestampForLoadedLibrary(module.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn GetXStateFeaturesMask(context: *const CONTEXT, featuremask: *mut u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn GetXStateFeaturesMask(context: *const CONTEXT, featuremask: *mut u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(GetXStateFeaturesMask(::core::mem::transmute(context), ::core::mem::transmute(featuremask)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScript(pub ::windows::core::IUnknown);
impl IActiveScript {
pub unsafe fn SetScriptSite<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptSite>>(&self, pass: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pass.into_param().abi()).ok()
}
pub unsafe fn GetScriptSite<T: ::windows::core::Interface>(&self) -> ::windows::core::Result<T> {
let mut result__ = ::core::option::Option::None;
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &<T as ::windows::core::Interface>::IID, &mut result__ as *mut _ as *mut _).and_some(result__)
}
pub unsafe fn SetScriptState(&self, ss: SCRIPTSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ss)).ok()
}
pub unsafe fn GetScriptState(&self) -> ::windows::core::Result<SCRIPTSTATE> {
let mut result__: <SCRIPTSTATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPTSTATE>(result__)
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddNamedItem<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrname: Param0, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pstrname.into_param().abi(), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn AddTypeLib(&self, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidtypelib), ::core::mem::transmute(dwmajor), ::core::mem::transmute(dwminor), ::core::mem::transmute(dwflags)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetScriptDispatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstritemname: Param0) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pstritemname.into_param().abi(), &mut result__).from_abi::<super::super::Com::IDispatch>(result__)
}
pub unsafe fn GetCurrentScriptThreadID(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetScriptThreadID(&self, dwwin32threadid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwwin32threadid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetScriptThreadState(&self, stidthread: u32) -> ::windows::core::Result<SCRIPTTHREADSTATE> {
let mut result__: <SCRIPTTHREADSTATE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(stidthread), &mut result__).from_abi::<SCRIPTTHREADSTATE>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn InterruptScriptThread(&self, stidthread: u32, pexcepinfo: *const super::super::Com::EXCEPINFO, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(stidthread), ::core::mem::transmute(pexcepinfo), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IActiveScript> {
let mut result__: <IActiveScript as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IActiveScript>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScript {
type Vtable = IActiveScript_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb1a2ae1_a4f9_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScript> for ::windows::core::IUnknown {
fn from(value: IActiveScript) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScript> for ::windows::core::IUnknown {
fn from(value: &IActiveScript) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScript_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pass: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ss: SCRIPTSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pssstate: *mut SCRIPTSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrname: super::super::super::Foundation::PWSTR, dwflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32, dwflags: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstritemname: super::super::super::Foundation::PWSTR, ppdisp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstidthread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwwin32threadid: u32, pstidthread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stidthread: u32, pstsstate: *mut SCRIPTTHREADSTATE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stidthread: u32, pexcepinfo: *const ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>, dwflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppscript: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptAuthor(pub ::windows::core::IUnknown);
impl IActiveScriptAuthor {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn AddNamedItem<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>>(&self, pszname: Param0, dwflags: u32, pdisp: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszname.into_param().abi(), ::core::mem::transmute(dwflags), pdisp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddScriptlet<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pszdefaultname: Param0,
pszcode: Param1,
pszitemname: Param2,
pszsubitemname: Param3,
pszeventname: Param4,
pszdelimiter: Param5,
dwcookie: u32,
dwflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszdefaultname.into_param().abi(), pszcode.into_param().abi(), pszitemname.into_param().abi(), pszsubitemname.into_param().abi(), pszeventname.into_param().abi(), pszdelimiter.into_param().abi(), ::core::mem::transmute(dwcookie), ::core::mem::transmute(dwflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ParseScriptText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszcode: Param0, pszitemname: Param1, pszdelimiter: Param2, dwcookie: u32, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszcode.into_param().abi(), pszitemname.into_param().abi(), pszdelimiter.into_param().abi(), ::core::mem::transmute(dwcookie), ::core::mem::transmute(dwflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszcode: Param0, cch: u32, pszdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszcode.into_param().abi(), ::core::mem::transmute(cch), pszdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptletTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszcode: Param0, cch: u32, pszdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszcode.into_param().abi(), ::core::mem::transmute(cch), pszdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
pub unsafe fn GetRoot(&self) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IScriptNode>(result__)
}
pub unsafe fn GetLanguageFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetEventHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pdisp: Param0, pszitem: Param1, pszsubitem: Param2, pszevent: Param3) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pdisp.into_param().abi(), pszitem.into_param().abi(), pszsubitem.into_param().abi(), pszevent.into_param().abi(), &mut result__).from_abi::<IScriptEntry>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveNamedItem<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszname.into_param().abi()).ok()
}
pub unsafe fn AddTypeLib(&self, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidtypelib), ::core::mem::transmute(dwmajor), ::core::mem::transmute(dwminor), ::core::mem::transmute(dwflags)).ok()
}
pub unsafe fn RemoveTypeLib(&self, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidtypelib), ::core::mem::transmute(dwmajor), ::core::mem::transmute(dwminor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetChars(&self, frequestedlist: u32) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(frequestedlist), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetInfoFromContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszcode: Param0, cchcode: u32, ichcurrentposition: u32, dwlisttypesrequested: u32, pdwlisttypesprovided: *mut u32, pichlistanchorposition: *mut u32, pichfuncanchorposition: *mut u32, pmemid: *mut i32, picurrentparameter: *mut i32, ppunk: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(
::core::mem::transmute_copy(self),
pszcode.into_param().abi(),
::core::mem::transmute(cchcode),
::core::mem::transmute(ichcurrentposition),
::core::mem::transmute(dwlisttypesrequested),
::core::mem::transmute(pdwlisttypesprovided),
::core::mem::transmute(pichlistanchorposition),
::core::mem::transmute(pichfuncanchorposition),
::core::mem::transmute(pmemid),
::core::mem::transmute(picurrentparameter),
::core::mem::transmute(ppunk),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsCommitChar(&self, ch: u16) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(ch), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptAuthor {
type Vtable = IActiveScriptAuthor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9c109da0_7006_11d1_b36c_00a0c911e8b2);
}
impl ::core::convert::From<IActiveScriptAuthor> for ::windows::core::IUnknown {
fn from(value: IActiveScriptAuthor) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptAuthor> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptAuthor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptAuthor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszname: super::super::super::Foundation::PWSTR, dwflags: u32, pdisp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdefaultname: super::super::super::Foundation::PWSTR, pszcode: super::super::super::Foundation::PWSTR, pszitemname: super::super::super::Foundation::PWSTR, pszsubitemname: super::super::super::Foundation::PWSTR, pszeventname: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, dwcookie: u32, dwflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcode: super::super::super::Foundation::PWSTR, pszitemname: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, dwcookie: u32, dwflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcode: super::super::super::Foundation::PWSTR, cch: u32, pszdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcode: super::super::super::Foundation::PWSTR, cch: u32, pszdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pgrfasa: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdisp: ::windows::core::RawPtr, pszitem: super::super::super::Foundation::PWSTR, pszsubitem: super::super::super::Foundation::PWSTR, pszevent: super::super::super::Foundation::PWSTR, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32, dwflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidtypelib: *const ::windows::core::GUID, dwmajor: u32, dwminor: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frequestedlist: u32, pbstrchars: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcode: super::super::super::Foundation::PWSTR, cchcode: u32, ichcurrentposition: u32, dwlisttypesrequested: u32, pdwlisttypesprovided: *mut u32, pichlistanchorposition: *mut u32, pichfuncanchorposition: *mut u32, pmemid: *mut i32, picurrentparameter: *mut i32, ppunk: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ch: u16, pfcommit: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptAuthorProcedure(pub ::windows::core::IUnknown);
impl IActiveScriptAuthorProcedure {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param7: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>,
>(
&self,
pszcode: Param0,
pszformalparams: Param1,
pszprocedurename: Param2,
pszitemname: Param3,
pszdelimiter: Param4,
dwcookie: u32,
dwflags: u32,
pdispfor: Param7,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszcode.into_param().abi(), pszformalparams.into_param().abi(), pszprocedurename.into_param().abi(), pszitemname.into_param().abi(), pszdelimiter.into_param().abi(), ::core::mem::transmute(dwcookie), ::core::mem::transmute(dwflags), pdispfor.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptAuthorProcedure {
type Vtable = IActiveScriptAuthorProcedure_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7e2d4b70_bd9a_11d0_9336_00a0c90dcaa9);
}
impl ::core::convert::From<IActiveScriptAuthorProcedure> for ::windows::core::IUnknown {
fn from(value: IActiveScriptAuthorProcedure) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptAuthorProcedure> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptAuthorProcedure) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptAuthorProcedure {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptAuthorProcedure {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptAuthorProcedure_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcode: super::super::super::Foundation::PWSTR, pszformalparams: super::super::super::Foundation::PWSTR, pszprocedurename: super::super::super::Foundation::PWSTR, pszitemname: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, dwcookie: u32, dwflags: u32, pdispfor: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptDebug32(pub ::windows::core::IUnknown);
impl IActiveScriptDebug32 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, unumcodechars: u32, pstrdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(unumcodechars), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptletTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, unumcodechars: u32, pstrdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(unumcodechars), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
pub unsafe fn EnumCodeContextsOfPosition(&self, dwsourcecontext: u32, ucharacteroffset: u32, unumchars: u32) -> ::windows::core::Result<IEnumDebugCodeContexts> {
let mut result__: <IEnumDebugCodeContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ucharacteroffset), ::core::mem::transmute(unumchars), &mut result__).from_abi::<IEnumDebugCodeContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptDebug32 {
type Vtable = IActiveScriptDebug32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c10_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IActiveScriptDebug32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptDebug32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptDebug32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptDebug32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptDebug32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptDebug32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptDebug32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, unumcodechars: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, unumcodechars: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u32, ucharacteroffset: u32, unumchars: u32, ppescc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptDebug64(pub ::windows::core::IUnknown);
impl IActiveScriptDebug64 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, unumcodechars: u32, pstrdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(unumcodechars), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptletTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, unumcodechars: u32, pstrdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(unumcodechars), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
pub unsafe fn EnumCodeContextsOfPosition(&self, dwsourcecontext: u64, ucharacteroffset: u32, unumchars: u32) -> ::windows::core::Result<IEnumDebugCodeContexts> {
let mut result__: <IEnumDebugCodeContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ucharacteroffset), ::core::mem::transmute(unumchars), &mut result__).from_abi::<IEnumDebugCodeContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptDebug64 {
type Vtable = IActiveScriptDebug64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc437e23_f5b8_47f4_bb79_7d1ce5483b86);
}
impl ::core::convert::From<IActiveScriptDebug64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptDebug64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptDebug64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptDebug64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptDebug64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptDebug64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptDebug64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, unumcodechars: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, unumcodechars: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u64, ucharacteroffset: u32, unumchars: u32, ppescc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptEncode(pub ::windows::core::IUnknown);
impl IActiveScriptEncode {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EncodeSection<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pchin: Param0, cchin: u32, pchout: Param2, cchout: u32, pcchret: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pchin.into_param().abi(), ::core::mem::transmute(cchin), pchout.into_param().abi(), ::core::mem::transmute(cchout), ::core::mem::transmute(pcchret)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DecodeScript<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pchin: Param0, cchin: u32, pchout: Param2, cchout: u32, pcchret: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pchin.into_param().abi(), ::core::mem::transmute(cchin), pchout.into_param().abi(), ::core::mem::transmute(cchout), ::core::mem::transmute(pcchret)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEncodeProgId(&self, pbstrout: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrout)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptEncode {
type Vtable = IActiveScriptEncode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb1a2ae3_a4f9_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScriptEncode> for ::windows::core::IUnknown {
fn from(value: IActiveScriptEncode) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptEncode> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptEncode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptEncode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptEncode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptEncode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pchin: super::super::super::Foundation::PWSTR, cchin: u32, pchout: super::super::super::Foundation::PWSTR, cchout: u32, pcchret: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pchin: super::super::super::Foundation::PWSTR, cchin: u32, pchout: super::super::super::Foundation::PWSTR, cchout: u32, pcchret: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrout: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptError(pub ::windows::core::IUnknown);
impl IActiveScriptError {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetExceptionInfo(&self) -> ::windows::core::Result<super::super::Com::EXCEPINFO> {
let mut result__: <super::super::Com::EXCEPINFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::EXCEPINFO>(result__)
}
pub unsafe fn GetSourcePosition(&self, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsourcecontext), ::core::mem::transmute(pullinenumber), ::core::mem::transmute(plcharacterposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceLineText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptError {
type Vtable = IActiveScriptError_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeae1ba61_a4ed_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScriptError> for ::windows::core::IUnknown {
fn from(value: IActiveScriptError) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptError> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptError) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptError {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptError {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptError_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrsourceline: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptError64(pub ::windows::core::IUnknown);
impl IActiveScriptError64 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetExceptionInfo(&self) -> ::windows::core::Result<super::super::Com::EXCEPINFO> {
let mut result__: <super::super::Com::EXCEPINFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::EXCEPINFO>(result__)
}
pub unsafe fn GetSourcePosition(&self, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsourcecontext), ::core::mem::transmute(pullinenumber), ::core::mem::transmute(plcharacterposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceLineText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetSourcePosition64(&self, pdwsourcecontext: *mut u64, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsourcecontext), ::core::mem::transmute(pullinenumber), ::core::mem::transmute(plcharacterposition)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptError64 {
type Vtable = IActiveScriptError64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb21fb2a1_5b8f_4963_8c21_21450f84ed7f);
}
impl ::core::convert::From<IActiveScriptError64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptError64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptError64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptError64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptError64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptError64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptError64> for IActiveScriptError {
fn from(value: IActiveScriptError64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptError64> for IActiveScriptError {
fn from(value: &IActiveScriptError64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for IActiveScriptError64 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for &IActiveScriptError64 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptError64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrsourceline: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsourcecontext: *mut u64, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptErrorDebug(pub ::windows::core::IUnknown);
impl IActiveScriptErrorDebug {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetExceptionInfo(&self) -> ::windows::core::Result<super::super::Com::EXCEPINFO> {
let mut result__: <super::super::Com::EXCEPINFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::EXCEPINFO>(result__)
}
pub unsafe fn GetSourcePosition(&self, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsourcecontext), ::core::mem::transmute(pullinenumber), ::core::mem::transmute(plcharacterposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceLineText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentContext(&self) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn GetStackFrame(&self) -> ::windows::core::Result<IDebugStackFrame> {
let mut result__: <IDebugStackFrame as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugStackFrame>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptErrorDebug {
type Vtable = IActiveScriptErrorDebug_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c12_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IActiveScriptErrorDebug> for ::windows::core::IUnknown {
fn from(value: IActiveScriptErrorDebug) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptErrorDebug> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptErrorDebug) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptErrorDebug> for IActiveScriptError {
fn from(value: IActiveScriptErrorDebug) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptErrorDebug> for IActiveScriptError {
fn from(value: &IActiveScriptErrorDebug) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for IActiveScriptErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for &IActiveScriptErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptErrorDebug_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrsourceline: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppssc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptErrorDebug110(pub ::windows::core::IUnknown);
impl IActiveScriptErrorDebug110 {
pub unsafe fn GetExceptionThrownKind(&self) -> ::windows::core::Result<SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND> {
let mut result__: <SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptErrorDebug110 {
type Vtable = IActiveScriptErrorDebug110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x516e42b6_89a8_4530_937b_5f0708431442);
}
impl ::core::convert::From<IActiveScriptErrorDebug110> for ::windows::core::IUnknown {
fn from(value: IActiveScriptErrorDebug110) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptErrorDebug110> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptErrorDebug110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptErrorDebug110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptErrorDebug110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptErrorDebug110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexceptionkind: *mut SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptGarbageCollector(pub ::windows::core::IUnknown);
impl IActiveScriptGarbageCollector {
pub unsafe fn CollectGarbage(&self, scriptgctype: SCRIPTGCTYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptgctype)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptGarbageCollector {
type Vtable = IActiveScriptGarbageCollector_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6aa2c4a0_2b53_11d4_a2a0_00104bd35090);
}
impl ::core::convert::From<IActiveScriptGarbageCollector> for ::windows::core::IUnknown {
fn from(value: IActiveScriptGarbageCollector) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptGarbageCollector> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptGarbageCollector) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptGarbageCollector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptGarbageCollector {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptGarbageCollector_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptgctype: SCRIPTGCTYPE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptHostEncode(pub ::windows::core::IUnknown);
impl IActiveScriptHostEncode {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EncodeScriptHostFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BSTR>>(&self, bstrinfile: Param0, pbstroutfile: *mut super::super::super::Foundation::BSTR, cflags: u32, bstrdefaultlang: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), bstrinfile.into_param().abi(), ::core::mem::transmute(pbstroutfile), ::core::mem::transmute(cflags), bstrdefaultlang.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptHostEncode {
type Vtable = IActiveScriptHostEncode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbee9b76e_cfe3_11d1_b747_00c04fc2b085);
}
impl ::core::convert::From<IActiveScriptHostEncode> for ::windows::core::IUnknown {
fn from(value: IActiveScriptHostEncode) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptHostEncode> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptHostEncode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptHostEncode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptHostEncode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptHostEncode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrinfile: ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pbstroutfile: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, cflags: u32, bstrdefaultlang: ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParse32(pub ::windows::core::IUnknown);
impl IActiveScriptParse32 {
pub unsafe fn InitNew(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn AddScriptlet<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrdefaultname: Param0,
pstrcode: Param1,
pstritemname: Param2,
pstrsubitemname: Param3,
pstreventname: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
pbstrname: *mut super::super::super::Foundation::BSTR,
pexcepinfo: *mut super::super::Com::EXCEPINFO,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(
::core::mem::transmute_copy(self),
pstrdefaultname.into_param().abi(),
pstrcode.into_param().abi(),
pstritemname.into_param().abi(),
pstrsubitemname.into_param().abi(),
pstreventname.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
::core::mem::transmute(pbstrname),
::core::mem::transmute(pexcepinfo),
)
.ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn ParseScriptText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
pstrcode: Param0,
pstritemname: Param1,
punkcontext: Param2,
pstrdelimiter: Param3,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
pvarresult: *mut super::super::Com::VARIANT,
pexcepinfo: *mut super::super::Com::EXCEPINFO,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParse32 {
type Vtable = IActiveScriptParse32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb1a2ae2_a4f9_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScriptParse32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParse32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParse32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParse32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParse32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParse32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParse32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrdefaultname: super::super::super::Foundation::PWSTR,
pstrcode: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
pstrsubitemname: super::super::super::Foundation::PWSTR,
pstreventname: super::super::super::Foundation::PWSTR,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>,
pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
pvarresult: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>,
pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParse64(pub ::windows::core::IUnknown);
impl IActiveScriptParse64 {
pub unsafe fn InitNew(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn AddScriptlet<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrdefaultname: Param0,
pstrcode: Param1,
pstritemname: Param2,
pstrsubitemname: Param3,
pstreventname: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
pbstrname: *mut super::super::super::Foundation::BSTR,
pexcepinfo: *mut super::super::Com::EXCEPINFO,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(
::core::mem::transmute_copy(self),
pstrdefaultname.into_param().abi(),
pstrcode.into_param().abi(),
pstritemname.into_param().abi(),
pstrsubitemname.into_param().abi(),
pstreventname.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
::core::mem::transmute(pbstrname),
::core::mem::transmute(pexcepinfo),
)
.ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn ParseScriptText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
pstrcode: Param0,
pstritemname: Param1,
punkcontext: Param2,
pstrdelimiter: Param3,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
pvarresult: *mut super::super::Com::VARIANT,
pexcepinfo: *mut super::super::Com::EXCEPINFO,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParse64 {
type Vtable = IActiveScriptParse64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc7ef7658_e1ee_480e_97ea_d52cb4d76d17);
}
impl ::core::convert::From<IActiveScriptParse64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParse64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParse64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParse64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParse64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParse64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParse64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrdefaultname: super::super::super::Foundation::PWSTR,
pstrcode: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
pstrsubitemname: super::super::super::Foundation::PWSTR,
pstreventname: super::super::super::Foundation::PWSTR,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>,
pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
pvarresult: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>,
pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedure2_32(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedure2_32 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstrprocedurename: Param2,
pstritemname: Param3,
punkcontext: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstrprocedurename.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedure2_32 {
type Vtable = IActiveScriptParseProcedure2_32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x71ee5b20_fb04_11d1_b3a8_00a0c911e8b2);
}
impl ::core::convert::From<IActiveScriptParseProcedure2_32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedure2_32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure2_32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedure2_32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedure2_32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedure2_32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptParseProcedure2_32> for IActiveScriptParseProcedure32 {
fn from(value: IActiveScriptParseProcedure2_32) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure2_32> for IActiveScriptParseProcedure32 {
fn from(value: &IActiveScriptParseProcedure2_32) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptParseProcedure32> for IActiveScriptParseProcedure2_32 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptParseProcedure32> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptParseProcedure32> for &IActiveScriptParseProcedure2_32 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptParseProcedure32> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedure2_32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstrformalparams: super::super::super::Foundation::PWSTR,
pstrprocedurename: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
ppdisp: *mut ::windows::core::RawPtr,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedure2_64(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedure2_64 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstrprocedurename: Param2,
pstritemname: Param3,
punkcontext: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstrprocedurename.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedure2_64 {
type Vtable = IActiveScriptParseProcedure2_64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfe7c4271_210c_448d_9f54_76dab7047b28);
}
impl ::core::convert::From<IActiveScriptParseProcedure2_64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedure2_64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure2_64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedure2_64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedure2_64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedure2_64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptParseProcedure2_64> for IActiveScriptParseProcedure64 {
fn from(value: IActiveScriptParseProcedure2_64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure2_64> for IActiveScriptParseProcedure64 {
fn from(value: &IActiveScriptParseProcedure2_64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptParseProcedure64> for IActiveScriptParseProcedure2_64 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptParseProcedure64> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptParseProcedure64> for &IActiveScriptParseProcedure2_64 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptParseProcedure64> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedure2_64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstrformalparams: super::super::super::Foundation::PWSTR,
pstrprocedurename: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
ppdisp: *mut ::windows::core::RawPtr,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedure32(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedure32 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstrprocedurename: Param2,
pstritemname: Param3,
punkcontext: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstrprocedurename.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedure32 {
type Vtable = IActiveScriptParseProcedure32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaa5b6a80_b834_11d0_932f_00a0c90dcaa9);
}
impl ::core::convert::From<IActiveScriptParseProcedure32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedure32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedure32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedure32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedure32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedure32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstrformalparams: super::super::super::Foundation::PWSTR,
pstrprocedurename: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
ppdisp: *mut ::windows::core::RawPtr,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedure64(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedure64 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<
'a,
Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>,
Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>,
>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstrprocedurename: Param2,
pstritemname: Param3,
punkcontext: Param4,
pstrdelimiter: Param5,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstrprocedurename.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedure64 {
type Vtable = IActiveScriptParseProcedure64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc64713b6_e029_4cc5_9200_438b72890b6a);
}
impl ::core::convert::From<IActiveScriptParseProcedure64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedure64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedure64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedure64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedure64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedure64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedure64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(
this: ::windows::core::RawPtr,
pstrcode: super::super::super::Foundation::PWSTR,
pstrformalparams: super::super::super::Foundation::PWSTR,
pstrprocedurename: super::super::super::Foundation::PWSTR,
pstritemname: super::super::super::Foundation::PWSTR,
punkcontext: ::windows::core::RawPtr,
pstrdelimiter: super::super::super::Foundation::PWSTR,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
ppdisp: *mut ::windows::core::RawPtr,
) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedureOld32(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedureOld32 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstritemname: Param2,
punkcontext: Param3,
pstrdelimiter: Param4,
dwsourcecontextcookie: u32,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedureOld32 {
type Vtable = IActiveScriptParseProcedureOld32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1cff0050_6fdd_11d0_9328_00a0c90dcaa9);
}
impl ::core::convert::From<IActiveScriptParseProcedureOld32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedureOld32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedureOld32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedureOld32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedureOld32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedureOld32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedureOld32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, pstrformalparams: super::super::super::Foundation::PWSTR, pstritemname: super::super::super::Foundation::PWSTR, punkcontext: ::windows::core::RawPtr, pstrdelimiter: super::super::super::Foundation::PWSTR, dwsourcecontextcookie: u32, ulstartinglinenumber: u32, dwflags: u32, ppdisp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptParseProcedureOld64(pub ::windows::core::IUnknown);
impl IActiveScriptParseProcedureOld64 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn ParseProcedureText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
pstrcode: Param0,
pstrformalparams: Param1,
pstritemname: Param2,
punkcontext: Param3,
pstrdelimiter: Param4,
dwsourcecontextcookie: u64,
ulstartinglinenumber: u32,
dwflags: u32,
) -> ::windows::core::Result<super::super::Com::IDispatch> {
let mut result__: <super::super::Com::IDispatch as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(
::core::mem::transmute_copy(self),
pstrcode.into_param().abi(),
pstrformalparams.into_param().abi(),
pstritemname.into_param().abi(),
punkcontext.into_param().abi(),
pstrdelimiter.into_param().abi(),
::core::mem::transmute(dwsourcecontextcookie),
::core::mem::transmute(ulstartinglinenumber),
::core::mem::transmute(dwflags),
&mut result__,
)
.from_abi::<super::super::Com::IDispatch>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptParseProcedureOld64 {
type Vtable = IActiveScriptParseProcedureOld64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x21f57128_08c9_4638_ba12_22d15d88dc5c);
}
impl ::core::convert::From<IActiveScriptParseProcedureOld64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptParseProcedureOld64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptParseProcedureOld64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptParseProcedureOld64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptParseProcedureOld64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptParseProcedureOld64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptParseProcedureOld64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, pstrformalparams: super::super::super::Foundation::PWSTR, pstritemname: super::super::super::Foundation::PWSTR, punkcontext: ::windows::core::RawPtr, pstrdelimiter: super::super::super::Foundation::PWSTR, dwsourcecontextcookie: u64, ulstartinglinenumber: u32, dwflags: u32, ppdisp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerCallback(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerCallback {
pub unsafe fn Initialize(&self, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn Shutdown(&self, hrreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrreason)).ok()
}
pub unsafe fn ScriptCompiled<'a, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(r#type), pidebugdocumentcontext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FunctionCompiled<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, functionid: i32, scriptid: i32, pwszfunctionname: Param2, pwszfunctionnamehint: Param3, pidebugdocumentcontext: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(functionid), ::core::mem::transmute(scriptid), pwszfunctionname.into_param().abi(), pwszfunctionnamehint.into_param().abi(), pidebugdocumentcontext.into_param().abi()).ok()
}
pub unsafe fn OnFunctionEnter(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
pub unsafe fn OnFunctionExit(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerCallback {
type Vtable = IActiveScriptProfilerCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x740eca23_7d9d_42e5_ba9d_f8b24b1c7a9b);
}
impl ::core::convert::From<IActiveScriptProfilerCallback> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, functionid: i32, scriptid: i32, pwszfunctionname: super::super::super::Foundation::PWSTR, pwszfunctionnamehint: super::super::super::Foundation::PWSTR, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerCallback2(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerCallback2 {
pub unsafe fn Initialize(&self, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn Shutdown(&self, hrreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrreason)).ok()
}
pub unsafe fn ScriptCompiled<'a, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(r#type), pidebugdocumentcontext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FunctionCompiled<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, functionid: i32, scriptid: i32, pwszfunctionname: Param2, pwszfunctionnamehint: Param3, pidebugdocumentcontext: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(functionid), ::core::mem::transmute(scriptid), pwszfunctionname.into_param().abi(), pwszfunctionnamehint.into_param().abi(), pidebugdocumentcontext.into_param().abi()).ok()
}
pub unsafe fn OnFunctionEnter(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
pub unsafe fn OnFunctionExit(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnFunctionEnterByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszfunctionname: Param0, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pwszfunctionname.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnFunctionExitByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszfunctionname: Param0, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pwszfunctionname.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerCallback2 {
type Vtable = IActiveScriptProfilerCallback2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31b7f8ad_a637_409c_b22f_040995b6103d);
}
impl ::core::convert::From<IActiveScriptProfilerCallback2> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerCallback2) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback2> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerCallback2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerCallback2> for IActiveScriptProfilerCallback {
fn from(value: IActiveScriptProfilerCallback2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback2> for IActiveScriptProfilerCallback {
fn from(value: &IActiveScriptProfilerCallback2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback> for IActiveScriptProfilerCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback> for &IActiveScriptProfilerCallback2 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerCallback2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, functionid: i32, scriptid: i32, pwszfunctionname: super::super::super::Foundation::PWSTR, pwszfunctionnamehint: super::super::super::Foundation::PWSTR, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfunctionname: super::super::super::Foundation::PWSTR, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfunctionname: super::super::super::Foundation::PWSTR, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerCallback3(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerCallback3 {
pub unsafe fn Initialize(&self, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn Shutdown(&self, hrreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrreason)).ok()
}
pub unsafe fn ScriptCompiled<'a, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(r#type), pidebugdocumentcontext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FunctionCompiled<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, functionid: i32, scriptid: i32, pwszfunctionname: Param2, pwszfunctionnamehint: Param3, pidebugdocumentcontext: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(functionid), ::core::mem::transmute(scriptid), pwszfunctionname.into_param().abi(), pwszfunctionnamehint.into_param().abi(), pidebugdocumentcontext.into_param().abi()).ok()
}
pub unsafe fn OnFunctionEnter(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
pub unsafe fn OnFunctionExit(&self, scriptid: i32, functionid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(scriptid), ::core::mem::transmute(functionid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnFunctionEnterByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszfunctionname: Param0, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pwszfunctionname.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnFunctionExitByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszfunctionname: Param0, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pwszfunctionname.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn SetWebWorkerId(&self, webworkerid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(webworkerid)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerCallback3 {
type Vtable = IActiveScriptProfilerCallback3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ac5ad25_2037_4687_91df_b59979d93d73);
}
impl ::core::convert::From<IActiveScriptProfilerCallback3> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerCallback3) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback3> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerCallback3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerCallback3> for IActiveScriptProfilerCallback2 {
fn from(value: IActiveScriptProfilerCallback3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback3> for IActiveScriptProfilerCallback2 {
fn from(value: &IActiveScriptProfilerCallback3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback2> for IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback2> for &IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerCallback3> for IActiveScriptProfilerCallback {
fn from(value: IActiveScriptProfilerCallback3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerCallback3> for IActiveScriptProfilerCallback {
fn from(value: &IActiveScriptProfilerCallback3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback> for IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerCallback> for &IActiveScriptProfilerCallback3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerCallback> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerCallback3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, r#type: PROFILER_SCRIPT_TYPE, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, functionid: i32, scriptid: i32, pwszfunctionname: super::super::super::Foundation::PWSTR, pwszfunctionnamehint: super::super::super::Foundation::PWSTR, pidebugdocumentcontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptid: i32, functionid: i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfunctionname: super::super::super::Foundation::PWSTR, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszfunctionname: super::super::super::Foundation::PWSTR, r#type: PROFILER_SCRIPT_TYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, webworkerid: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerControl(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerControl {
pub unsafe fn StartProfiling(&self, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidprofilerobject), ::core::mem::transmute(dweventmask), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn SetProfilerEventMask(&self, dweventmask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dweventmask)).ok()
}
pub unsafe fn StopProfiling(&self, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrshutdownreason)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerControl {
type Vtable = IActiveScriptProfilerControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x784b5ff0_69b0_47d1_a7dc_2518f4230e90);
}
impl ::core::convert::From<IActiveScriptProfilerControl> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dweventmask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerControl2(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerControl2 {
pub unsafe fn StartProfiling(&self, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidprofilerobject), ::core::mem::transmute(dweventmask), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn SetProfilerEventMask(&self, dweventmask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dweventmask)).ok()
}
pub unsafe fn StopProfiling(&self, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrshutdownreason)).ok()
}
pub unsafe fn CompleteProfilerStart(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn PrepareProfilerStop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerControl2 {
type Vtable = IActiveScriptProfilerControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47810165_498f_40be_94f1_653557e9e7da);
}
impl ::core::convert::From<IActiveScriptProfilerControl2> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl2> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerControl2> for IActiveScriptProfilerControl {
fn from(value: IActiveScriptProfilerControl2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl2> for IActiveScriptProfilerControl {
fn from(value: &IActiveScriptProfilerControl2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for IActiveScriptProfilerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for &IActiveScriptProfilerControl2 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dweventmask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerControl3(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerControl3 {
pub unsafe fn StartProfiling(&self, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidprofilerobject), ::core::mem::transmute(dweventmask), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn SetProfilerEventMask(&self, dweventmask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dweventmask)).ok()
}
pub unsafe fn StopProfiling(&self, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrshutdownreason)).ok()
}
pub unsafe fn CompleteProfilerStart(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn PrepareProfilerStop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumHeap(&self) -> ::windows::core::Result<IActiveScriptProfilerHeapEnum> {
let mut result__: <IActiveScriptProfilerHeapEnum as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IActiveScriptProfilerHeapEnum>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerControl3 {
type Vtable = IActiveScriptProfilerControl3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0b403015_f381_4023_a5d0_6fed076de716);
}
impl ::core::convert::From<IActiveScriptProfilerControl3> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerControl3) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl3> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerControl3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerControl3> for IActiveScriptProfilerControl2 {
fn from(value: IActiveScriptProfilerControl3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl3> for IActiveScriptProfilerControl2 {
fn from(value: &IActiveScriptProfilerControl3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for &IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl3> for IActiveScriptProfilerControl {
fn from(value: IActiveScriptProfilerControl3) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl3> for IActiveScriptProfilerControl {
fn from(value: &IActiveScriptProfilerControl3) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for &IActiveScriptProfilerControl3 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerControl3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dweventmask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerControl4(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerControl4 {
pub unsafe fn StartProfiling(&self, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidprofilerobject), ::core::mem::transmute(dweventmask), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn SetProfilerEventMask(&self, dweventmask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dweventmask)).ok()
}
pub unsafe fn StopProfiling(&self, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrshutdownreason)).ok()
}
pub unsafe fn CompleteProfilerStart(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn PrepareProfilerStop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumHeap(&self) -> ::windows::core::Result<IActiveScriptProfilerHeapEnum> {
let mut result__: <IActiveScriptProfilerHeapEnum as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IActiveScriptProfilerHeapEnum>(result__)
}
pub unsafe fn SummarizeHeap(&self, heapsummary: *mut PROFILER_HEAP_SUMMARY) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(heapsummary)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerControl4 {
type Vtable = IActiveScriptProfilerControl4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x160f94fd_9dbc_40d4_9eac_2b71db3132f4);
}
impl ::core::convert::From<IActiveScriptProfilerControl4> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerControl4) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl4> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerControl4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerControl4> for IActiveScriptProfilerControl3 {
fn from(value: IActiveScriptProfilerControl4) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl4> for IActiveScriptProfilerControl3 {
fn from(value: &IActiveScriptProfilerControl4) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl3> for IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl3> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl3> for &IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl3> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl4> for IActiveScriptProfilerControl2 {
fn from(value: IActiveScriptProfilerControl4) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl4> for IActiveScriptProfilerControl2 {
fn from(value: &IActiveScriptProfilerControl4) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for &IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl4> for IActiveScriptProfilerControl {
fn from(value: IActiveScriptProfilerControl4) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl4> for IActiveScriptProfilerControl {
fn from(value: &IActiveScriptProfilerControl4) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for &IActiveScriptProfilerControl4 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerControl4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dweventmask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, heapsummary: *mut PROFILER_HEAP_SUMMARY) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerControl5(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerControl5 {
pub unsafe fn StartProfiling(&self, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidprofilerobject), ::core::mem::transmute(dweventmask), ::core::mem::transmute(dwcontext)).ok()
}
pub unsafe fn SetProfilerEventMask(&self, dweventmask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dweventmask)).ok()
}
pub unsafe fn StopProfiling(&self, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrshutdownreason)).ok()
}
pub unsafe fn CompleteProfilerStart(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn PrepareProfilerStop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumHeap(&self) -> ::windows::core::Result<IActiveScriptProfilerHeapEnum> {
let mut result__: <IActiveScriptProfilerHeapEnum as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IActiveScriptProfilerHeapEnum>(result__)
}
pub unsafe fn SummarizeHeap(&self, heapsummary: *mut PROFILER_HEAP_SUMMARY) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(heapsummary)).ok()
}
pub unsafe fn EnumHeap2(&self, enumflags: PROFILER_HEAP_ENUM_FLAGS) -> ::windows::core::Result<IActiveScriptProfilerHeapEnum> {
let mut result__: <IActiveScriptProfilerHeapEnum as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(enumflags), &mut result__).from_abi::<IActiveScriptProfilerHeapEnum>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerControl5 {
type Vtable = IActiveScriptProfilerControl5_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1c01a2d1_8f0f_46a5_9720_0d7ed2c62f0a);
}
impl ::core::convert::From<IActiveScriptProfilerControl5> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerControl5) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl5> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerControl5) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptProfilerControl5> for IActiveScriptProfilerControl4 {
fn from(value: IActiveScriptProfilerControl5) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl5> for IActiveScriptProfilerControl4 {
fn from(value: &IActiveScriptProfilerControl5) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl4> for IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl4> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl4> for &IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl4> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl5> for IActiveScriptProfilerControl3 {
fn from(value: IActiveScriptProfilerControl5) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl5> for IActiveScriptProfilerControl3 {
fn from(value: &IActiveScriptProfilerControl5) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl3> for IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl3> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl3> for &IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl3> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl5> for IActiveScriptProfilerControl2 {
fn from(value: IActiveScriptProfilerControl5) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl5> for IActiveScriptProfilerControl2 {
fn from(value: &IActiveScriptProfilerControl5) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl2> for &IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl2> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IActiveScriptProfilerControl5> for IActiveScriptProfilerControl {
fn from(value: IActiveScriptProfilerControl5) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptProfilerControl5> for IActiveScriptProfilerControl {
fn from(value: &IActiveScriptProfilerControl5) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptProfilerControl> for &IActiveScriptProfilerControl5 {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptProfilerControl> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerControl5_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidprofilerobject: *const ::windows::core::GUID, dweventmask: u32, dwcontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dweventmask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrshutdownreason: ::windows::core::HRESULT) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, heapsummary: *mut PROFILER_HEAP_SUMMARY) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumflags: PROFILER_HEAP_ENUM_FLAGS, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProfilerHeapEnum(pub ::windows::core::IUnknown);
impl IActiveScriptProfilerHeapEnum {
pub unsafe fn Next(&self, celt: u32, heapobjects: *mut *mut PROFILER_HEAP_OBJECT, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(heapobjects), ::core::mem::transmute(pceltfetched)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOptionalInfo(&self, heapobject: *const PROFILER_HEAP_OBJECT, celt: u32, optionalinfo: *mut PROFILER_HEAP_OBJECT_OPTIONAL_INFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(heapobject), ::core::mem::transmute(celt), ::core::mem::transmute(optionalinfo)).ok()
}
pub unsafe fn FreeObjectAndOptionalInfo(&self, celt: u32, heapobjects: *const *const PROFILER_HEAP_OBJECT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(heapobjects)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameIdMap(&self, pnamelist: *mut *mut *mut super::super::super::Foundation::PWSTR, pcelt: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pnamelist), ::core::mem::transmute(pcelt)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProfilerHeapEnum {
type Vtable = IActiveScriptProfilerHeapEnum_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x32e4694e_0d37_419b_b93d_fa20ded6e8ea);
}
impl ::core::convert::From<IActiveScriptProfilerHeapEnum> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProfilerHeapEnum) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProfilerHeapEnum> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProfilerHeapEnum) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProfilerHeapEnum {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProfilerHeapEnum {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProfilerHeapEnum_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, heapobjects: *mut *mut PROFILER_HEAP_OBJECT, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, heapobject: *const PROFILER_HEAP_OBJECT, celt: u32, optionalinfo: *mut PROFILER_HEAP_OBJECT_OPTIONAL_INFO) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, heapobjects: *const *const PROFILER_HEAP_OBJECT) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnamelist: *mut *mut *mut super::super::super::Foundation::PWSTR, pcelt: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptProperty(pub ::windows::core::IUnknown);
impl IActiveScriptProperty {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetProperty(&self, dwproperty: u32, pvarindex: *const super::super::Com::VARIANT) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), ::core::mem::transmute(pvarindex), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetProperty(&self, dwproperty: u32, pvarindex: *const super::super::Com::VARIANT, pvarvalue: *const super::super::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwproperty), ::core::mem::transmute(pvarindex), ::core::mem::transmute(pvarvalue)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptProperty {
type Vtable = IActiveScriptProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4954e0d0_fbc7_11d1_8410_006008c3fbfc);
}
impl ::core::convert::From<IActiveScriptProperty> for ::windows::core::IUnknown {
fn from(value: IActiveScriptProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptProperty> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pvarindex: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, pvarvalue: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwproperty: u32, pvarindex: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, pvarvalue: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSIPInfo(pub ::windows::core::IUnknown);
impl IActiveScriptSIPInfo {
pub unsafe fn GetSIPOID(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSIPInfo {
type Vtable = IActiveScriptSIPInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x764651d0_38de_11d4_a2a3_00104bd35090);
}
impl ::core::convert::From<IActiveScriptSIPInfo> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSIPInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSIPInfo> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSIPInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSIPInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSIPInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSIPInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poid_sip: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSite(pub ::windows::core::IUnknown);
impl IActiveScriptSite {
pub unsafe fn GetLCID(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetItemInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrname: Param0, dwreturnmask: u32, ppiunkitem: *mut ::core::option::Option<::windows::core::IUnknown>, ppti: *mut ::core::option::Option<super::super::Com::ITypeInfo>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pstrname.into_param().abi(), ::core::mem::transmute(dwreturnmask), ::core::mem::transmute(ppiunkitem), ::core::mem::transmute(ppti)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDocVersionString(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn OnScriptTerminate(&self, pvarresult: *const super::super::Com::VARIANT, pexcepinfo: *const super::super::Com::EXCEPINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvarresult), ::core::mem::transmute(pexcepinfo)).ok()
}
pub unsafe fn OnStateChange(&self, ssscriptstate: SCRIPTSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ssscriptstate)).ok()
}
pub unsafe fn OnScriptError<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptError>>(&self, pscripterror: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pscripterror.into_param().abi()).ok()
}
pub unsafe fn OnEnterScript(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnLeaveScript(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSite {
type Vtable = IActiveScriptSite_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb01a1e3_a42b_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScriptSite> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSite) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSite> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSite) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSite {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSite {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSite_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plcid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrname: super::super::super::Foundation::PWSTR, dwreturnmask: u32, ppiunkitem: *mut ::windows::core::RawPtr, ppti: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrversion: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvarresult: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, pexcepinfo: *const ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ssscriptstate: SCRIPTSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pscripterror: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteDebug32(pub ::windows::core::IUnknown);
impl IActiveScriptSiteDebug32 {
pub unsafe fn GetDocumentContextFromPosition(&self, dwsourcecontext: u32, ucharacteroffset: u32, unumchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ucharacteroffset), ::core::mem::transmute(unumchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn GetApplication(&self) -> ::windows::core::Result<IDebugApplication32> {
let mut result__: <IDebugApplication32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication32>(result__)
}
pub unsafe fn GetRootApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnScriptErrorDebug<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>>(&self, perrordebug: Param0, pfenterdebugger: *mut super::super::super::Foundation::BOOL, pfcallonscripterrorwhencontinuing: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), perrordebug.into_param().abi(), ::core::mem::transmute(pfenterdebugger), ::core::mem::transmute(pfcallonscripterrorwhencontinuing)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteDebug32 {
type Vtable = IActiveScriptSiteDebug32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c11_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IActiveScriptSiteDebug32> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteDebug32) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteDebug32> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteDebug32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteDebug32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteDebug32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteDebug32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u32, ucharacteroffset: u32, unumchars: u32, ppsc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdanroot: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, perrordebug: ::windows::core::RawPtr, pfenterdebugger: *mut super::super::super::Foundation::BOOL, pfcallonscripterrorwhencontinuing: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteDebug64(pub ::windows::core::IUnknown);
impl IActiveScriptSiteDebug64 {
pub unsafe fn GetDocumentContextFromPosition(&self, dwsourcecontext: u64, ucharacteroffset: u32, unumchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ucharacteroffset), ::core::mem::transmute(unumchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn GetApplication(&self) -> ::windows::core::Result<IDebugApplication64> {
let mut result__: <IDebugApplication64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication64>(result__)
}
pub unsafe fn GetRootApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnScriptErrorDebug<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>>(&self, perrordebug: Param0, pfenterdebugger: *mut super::super::super::Foundation::BOOL, pfcallonscripterrorwhencontinuing: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), perrordebug.into_param().abi(), ::core::mem::transmute(pfenterdebugger), ::core::mem::transmute(pfcallonscripterrorwhencontinuing)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteDebug64 {
type Vtable = IActiveScriptSiteDebug64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd6b96b0a_7463_402c_92ac_89984226942f);
}
impl ::core::convert::From<IActiveScriptSiteDebug64> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteDebug64) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteDebug64> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteDebug64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteDebug64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteDebug64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteDebug64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u64, ucharacteroffset: u32, unumchars: u32, ppsc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdanroot: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, perrordebug: ::windows::core::RawPtr, pfenterdebugger: *mut super::super::super::Foundation::BOOL, pfcallonscripterrorwhencontinuing: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteDebugEx(pub ::windows::core::IUnknown);
impl IActiveScriptSiteDebugEx {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnCanNotJITScriptErrorDebug<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>>(&self, perrordebug: Param0) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), perrordebug.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteDebugEx {
type Vtable = IActiveScriptSiteDebugEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbb722ccb_6ad2_41c6_b780_af9c03ee69f5);
}
impl ::core::convert::From<IActiveScriptSiteDebugEx> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteDebugEx) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteDebugEx> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteDebugEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteDebugEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteDebugEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteDebugEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, perrordebug: ::windows::core::RawPtr, pfcallonscripterrorwhencontinuing: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteInterruptPoll(pub ::windows::core::IUnknown);
impl IActiveScriptSiteInterruptPoll {
pub unsafe fn QueryContinue(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteInterruptPoll {
type Vtable = IActiveScriptSiteInterruptPoll_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x539698a0_cdca_11cf_a5eb_00aa0047a063);
}
impl ::core::convert::From<IActiveScriptSiteInterruptPoll> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteInterruptPoll) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteInterruptPoll> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteInterruptPoll) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteInterruptPoll {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteInterruptPoll {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteInterruptPoll_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteTraceInfo(pub ::windows::core::IUnknown);
impl IActiveScriptSiteTraceInfo {
pub unsafe fn SendScriptTraceInfo<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, stieventtype: SCRIPTTRACEINFO, guidcontextid: Param1, dwscriptcontextcookie: u32, lscriptstatementstart: i32, lscriptstatementend: i32, dwreserved: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(stieventtype), guidcontextid.into_param().abi(), ::core::mem::transmute(dwscriptcontextcookie), ::core::mem::transmute(lscriptstatementstart), ::core::mem::transmute(lscriptstatementend), ::core::mem::transmute(dwreserved)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteTraceInfo {
type Vtable = IActiveScriptSiteTraceInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4b7272ae_1955_4bfe_98b0_780621888569);
}
impl ::core::convert::From<IActiveScriptSiteTraceInfo> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteTraceInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteTraceInfo> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteTraceInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteTraceInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteTraceInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteTraceInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stieventtype: SCRIPTTRACEINFO, guidcontextid: ::windows::core::GUID, dwscriptcontextcookie: u32, lscriptstatementstart: i32, lscriptstatementend: i32, dwreserved: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteUIControl(pub ::windows::core::IUnknown);
impl IActiveScriptSiteUIControl {
pub unsafe fn GetUIBehavior(&self, uicitem: SCRIPTUICITEM) -> ::windows::core::Result<SCRIPTUICHANDLING> {
let mut result__: <SCRIPTUICHANDLING as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(uicitem), &mut result__).from_abi::<SCRIPTUICHANDLING>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteUIControl {
type Vtable = IActiveScriptSiteUIControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaedae97e_d7ee_4796_b960_7f092ae844ab);
}
impl ::core::convert::From<IActiveScriptSiteUIControl> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteUIControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteUIControl> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteUIControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteUIControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteUIControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteUIControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uicitem: SCRIPTUICITEM, puichandling: *mut SCRIPTUICHANDLING) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptSiteWindow(pub ::windows::core::IUnknown);
impl IActiveScriptSiteWindow {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWindow(&self) -> ::windows::core::Result<super::super::super::Foundation::HWND> {
let mut result__: <super::super::super::Foundation::HWND as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::HWND>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnableModeless<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, fenable: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), fenable.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptSiteWindow {
type Vtable = IActiveScriptSiteWindow_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd10f6761_83e9_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IActiveScriptSiteWindow> for ::windows::core::IUnknown {
fn from(value: IActiveScriptSiteWindow) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptSiteWindow> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptSiteWindow) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptSiteWindow {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptSiteWindow {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptSiteWindow_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phwnd: *mut super::super::super::Foundation::HWND) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fenable: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptStats(pub ::windows::core::IUnknown);
impl IActiveScriptStats {
pub unsafe fn GetStat(&self, stid: u32, pluhi: *mut u32, plulo: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(stid), ::core::mem::transmute(pluhi), ::core::mem::transmute(plulo)).ok()
}
pub unsafe fn GetStatEx(&self, guid: *const ::windows::core::GUID, pluhi: *mut u32, plulo: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), ::core::mem::transmute(pluhi), ::core::mem::transmute(plulo)).ok()
}
pub unsafe fn ResetStats(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptStats {
type Vtable = IActiveScriptStats_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8da6310_e19b_11d0_933c_00a0c90dcaa9);
}
impl ::core::convert::From<IActiveScriptStats> for ::windows::core::IUnknown {
fn from(value: IActiveScriptStats) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptStats> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptStats) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptStats {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptStats {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptStats_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stid: u32, pluhi: *mut u32, plulo: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, pluhi: *mut u32, plulo: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptStringCompare(pub ::windows::core::IUnknown);
impl IActiveScriptStringCompare {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StrComp<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BSTR>>(&self, bszstr1: Param0, bszstr2: Param1) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), bszstr1.into_param().abi(), bszstr2.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptStringCompare {
type Vtable = IActiveScriptStringCompare_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x58562769_ed52_42f7_8403_4963514e1f11);
}
impl ::core::convert::From<IActiveScriptStringCompare> for ::windows::core::IUnknown {
fn from(value: IActiveScriptStringCompare) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptStringCompare> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptStringCompare) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptStringCompare {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptStringCompare {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptStringCompare_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bszstr1: ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, bszstr2: ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, iret: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptTraceInfo(pub ::windows::core::IUnknown);
impl IActiveScriptTraceInfo {
pub unsafe fn StartScriptTracing<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptSiteTraceInfo>, Param1: ::windows::core::IntoParam<'a, ::windows::core::GUID>>(&self, psitetraceinfo: Param0, guidcontextid: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psitetraceinfo.into_param().abi(), guidcontextid.into_param().abi()).ok()
}
pub unsafe fn StopScriptTracing(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IActiveScriptTraceInfo {
type Vtable = IActiveScriptTraceInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc35456e7_bebf_4a1b_86a9_24d56be8b369);
}
impl ::core::convert::From<IActiveScriptTraceInfo> for ::windows::core::IUnknown {
fn from(value: IActiveScriptTraceInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptTraceInfo> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptTraceInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptTraceInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptTraceInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptTraceInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psitetraceinfo: ::windows::core::RawPtr, guidcontextid: ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IActiveScriptWinRTErrorDebug(pub ::windows::core::IUnknown);
impl IActiveScriptWinRTErrorDebug {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn GetExceptionInfo(&self) -> ::windows::core::Result<super::super::Com::EXCEPINFO> {
let mut result__: <super::super::Com::EXCEPINFO as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::EXCEPINFO>(result__)
}
pub unsafe fn GetSourcePosition(&self, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwsourcecontext), ::core::mem::transmute(pullinenumber), ::core::mem::transmute(plcharacterposition)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceLineText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRestrictedErrorString(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRestrictedErrorReference(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCapabilitySid(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IActiveScriptWinRTErrorDebug {
type Vtable = IActiveScriptWinRTErrorDebug_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73a3f82a_0fe9_4b33_ba3b_fe095f697e0a);
}
impl ::core::convert::From<IActiveScriptWinRTErrorDebug> for ::windows::core::IUnknown {
fn from(value: IActiveScriptWinRTErrorDebug) -> Self {
value.0
}
}
impl ::core::convert::From<&IActiveScriptWinRTErrorDebug> for ::windows::core::IUnknown {
fn from(value: &IActiveScriptWinRTErrorDebug) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IActiveScriptWinRTErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IActiveScriptWinRTErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IActiveScriptWinRTErrorDebug> for IActiveScriptError {
fn from(value: IActiveScriptWinRTErrorDebug) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IActiveScriptWinRTErrorDebug> for IActiveScriptError {
fn from(value: &IActiveScriptWinRTErrorDebug) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for IActiveScriptWinRTErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IActiveScriptError> for &IActiveScriptWinRTErrorDebug {
fn into_param(self) -> ::windows::core::Param<'a, IActiveScriptError> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IActiveScriptWinRTErrorDebug_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwsourcecontext: *mut u32, pullinenumber: *mut u32, plcharacterposition: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrsourceline: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, errorstring: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, referencestring: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, capabilitysid: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IApplicationDebugger(pub ::windows::core::IUnknown);
impl IApplicationDebugger {
pub unsafe fn QueryAlive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CreateInstanceAtDebugger<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, rclsid: *const ::windows::core::GUID, punkouter: Param1, dwclscontext: u32, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(rclsid), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn onDebugOutput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstr: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pstr.into_param().abi()).ok()
}
pub unsafe fn onHandleBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>, Param2: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>>(&self, prpt: Param0, br: BREAKREASON, perror: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), prpt.into_param().abi(), ::core::mem::transmute(br), perror.into_param().abi()).ok()
}
pub unsafe fn onClose(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn onDebuggerEvent<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, riid: *const ::windows::core::GUID, punk: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), punk.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IApplicationDebugger {
type Vtable = IApplicationDebugger_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2a_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IApplicationDebugger> for ::windows::core::IUnknown {
fn from(value: IApplicationDebugger) -> Self {
value.0
}
}
impl ::core::convert::From<&IApplicationDebugger> for ::windows::core::IUnknown {
fn from(value: &IApplicationDebugger) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IApplicationDebugger {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IApplicationDebugger {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IApplicationDebugger_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rclsid: *const ::windows::core::GUID, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstr: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prpt: ::windows::core::RawPtr, br: BREAKREASON, perror: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IApplicationDebuggerUI(pub ::windows::core::IUnknown);
impl IApplicationDebuggerUI {
pub unsafe fn BringDocumentToTop<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentText>>(&self, pddt: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pddt.into_param().abi()).ok()
}
pub unsafe fn BringDocumentContextToTop<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentContext>>(&self, pddc: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pddc.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IApplicationDebuggerUI {
type Vtable = IApplicationDebuggerUI_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2b_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IApplicationDebuggerUI> for ::windows::core::IUnknown {
fn from(value: IApplicationDebuggerUI) -> Self {
value.0
}
}
impl ::core::convert::From<&IApplicationDebuggerUI> for ::windows::core::IUnknown {
fn from(value: &IApplicationDebuggerUI) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IApplicationDebuggerUI {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IApplicationDebuggerUI {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IApplicationDebuggerUI_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddt: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddc: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IBindEventHandler(pub ::windows::core::IUnknown);
impl IBindEventHandler {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn BindHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>>(&self, pstrevent: Param0, pdisp: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstrevent.into_param().abi(), pdisp.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IBindEventHandler {
type Vtable = IBindEventHandler_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x63cdbcb0_c1b1_11d0_9336_00a0c90dcaa9);
}
impl ::core::convert::From<IBindEventHandler> for ::windows::core::IUnknown {
fn from(value: IBindEventHandler) -> Self {
value.0
}
}
impl ::core::convert::From<&IBindEventHandler> for ::windows::core::IUnknown {
fn from(value: &IBindEventHandler) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IBindEventHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IBindEventHandler {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IBindEventHandler_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrevent: super::super::super::Foundation::PWSTR, pdisp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ICodeAddressConcept(pub ::windows::core::IUnknown);
impl ICodeAddressConcept {
pub unsafe fn GetContainingSymbol<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, pcontextobject: Param0) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcontextobject.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
}
unsafe impl ::windows::core::Interface for ICodeAddressConcept {
type Vtable = ICodeAddressConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc7371568_5c78_4a00_a4ab_6ef8823184cb);
}
impl ::core::convert::From<ICodeAddressConcept> for ::windows::core::IUnknown {
fn from(value: ICodeAddressConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&ICodeAddressConcept> for ::windows::core::IUnknown {
fn from(value: &ICodeAddressConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ICodeAddressConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ICodeAddressConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ICodeAddressConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcontextobject: ::windows::core::RawPtr, ppsymbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IComparableConcept(pub ::windows::core::IUnknown);
impl IComparableConcept {
pub unsafe fn CompareObjects<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0, otherobject: Param1) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), otherobject.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for IComparableConcept {
type Vtable = IComparableConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7830646_9f0c_4a31_ba19_503f33e6c8a3);
}
impl ::core::convert::From<IComparableConcept> for ::windows::core::IUnknown {
fn from(value: IComparableConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IComparableConcept> for ::windows::core::IUnknown {
fn from(value: &IComparableConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IComparableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IComparableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IComparableConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, otherobject: ::windows::core::RawPtr, comparisonresult: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelConcept(pub ::windows::core::IUnknown);
impl IDataModelConcept {
pub unsafe fn InitializeObject<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>, Param2: ::windows::core::IntoParam<'a, IDebugHostSymbolEnumerator>>(&self, modelobject: Param0, matchingtypesignature: Param1, wildcardmatches: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), modelobject.into_param().abi(), matchingtypesignature.into_param().abi(), wildcardmatches.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelConcept {
type Vtable = IDataModelConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfcb98d1d_1114_4fbf_b24c_effcb5def0d3);
}
impl ::core::convert::From<IDataModelConcept> for ::windows::core::IUnknown {
fn from(value: IDataModelConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelConcept> for ::windows::core::IUnknown {
fn from(value: &IDataModelConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelobject: ::windows::core::RawPtr, matchingtypesignature: ::windows::core::RawPtr, wildcardmatches: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelManager(pub ::windows::core::IUnknown);
impl IDataModelManager {
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CreateNoValue(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateErrorObject<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, hrerror: ::windows::core::HRESULT, pwszmessage: Param1) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrerror), pwszmessage.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateTypedObject<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, context: Param0, objectlocation: Param1, objecttype: Param2) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), context.into_param().abi(), objectlocation.into_param().abi(), objecttype.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateTypedObjectReference<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, context: Param0, objectlocation: Param1, objecttype: Param2) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), context.into_param().abi(), objectlocation.into_param().abi(), objecttype.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateSyntheticObject<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>>(&self, context: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), context.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateDataModelObject<'a, Param0: ::windows::core::IntoParam<'a, IDataModelConcept>>(&self, datamodel: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const super::super::Com::VARIANT) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(objectkind), ::core::mem::transmute(intrinsicdata), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateTypedIntrinsicObject<'a, Param1: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, intrinsicdata: *const super::super::Com::VARIANT, r#type: Param1) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, typesignature: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetModelForType<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, r#type: Param0, datamodel: *mut ::core::option::Option<IModelObject>, typesignature: *mut ::core::option::Option<IDebugHostTypeSignature>, wildcardmatches: *mut ::core::option::Option<IDebugHostSymbolEnumerator>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), r#type.into_param().abi(), ::core::mem::transmute(datamodel), ::core::mem::transmute(typesignature), ::core::mem::transmute(wildcardmatches)).ok()
}
pub unsafe fn RegisterModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, typesignature: Param0, datamodel: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), datamodel.into_param().abi()).ok()
}
pub unsafe fn UnregisterModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, datamodel: Param0, typesignature: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), typesignature.into_param().abi()).ok()
}
pub unsafe fn RegisterExtensionForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, typesignature: Param0, datamodel: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), datamodel.into_param().abi()).ok()
}
pub unsafe fn UnregisterExtensionForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, datamodel: Param0, typesignature: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), typesignature.into_param().abi()).ok()
}
pub unsafe fn CreateMetadataStore<'a, Param0: ::windows::core::IntoParam<'a, IKeyStore>>(&self, parentstore: Param0) -> ::windows::core::Result<IKeyStore> {
let mut result__: <IKeyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), parentstore.into_param().abi(), &mut result__).from_abi::<IKeyStore>(result__)
}
pub unsafe fn GetRootNamespace(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RegisterNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, modelname: Param0, modeobject: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), modelname.into_param().abi(), modeobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnregisterNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, modelname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), modelname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AcquireNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, modelname: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), modelname.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelManager {
type Vtable = IDataModelManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73fe19f4_a110_4500_8ed9_3c28896f508c);
}
impl ::core::convert::From<IDataModelManager> for ::windows::core::IUnknown {
fn from(value: IDataModelManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelManager> for ::windows::core::IUnknown {
fn from(value: &IDataModelManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrerror: ::windows::core::HRESULT, pwszmessage: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, objectlocation: Location, objecttype: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, objectlocation: Location, objecttype: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectkind: ModelObjectKind, intrinsicdata: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, intrinsicdata: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, r#type: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::windows::core::RawPtr, datamodel: *mut ::windows::core::RawPtr, typesignature: *mut ::windows::core::RawPtr, wildcardmatches: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parentstore: ::windows::core::RawPtr, metadatastore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rootnamespace: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR, modeobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR, modelobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelManager2(pub ::windows::core::IUnknown);
impl IDataModelManager2 {
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn CreateNoValue(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateErrorObject<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, hrerror: ::windows::core::HRESULT, pwszmessage: Param1) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrerror), pwszmessage.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateTypedObject<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, context: Param0, objectlocation: Param1, objecttype: Param2) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), context.into_param().abi(), objectlocation.into_param().abi(), objecttype.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateTypedObjectReference<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, context: Param0, objectlocation: Param1, objecttype: Param2) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), context.into_param().abi(), objectlocation.into_param().abi(), objecttype.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateSyntheticObject<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>>(&self, context: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), context.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn CreateDataModelObject<'a, Param0: ::windows::core::IntoParam<'a, IDataModelConcept>>(&self, datamodel: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateIntrinsicObject(&self, objectkind: ModelObjectKind, intrinsicdata: *const super::super::Com::VARIANT) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(objectkind), ::core::mem::transmute(intrinsicdata), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateTypedIntrinsicObject<'a, Param1: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, intrinsicdata: *const super::super::Com::VARIANT, r#type: Param1) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, typesignature: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetModelForType<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, r#type: Param0, datamodel: *mut ::core::option::Option<IModelObject>, typesignature: *mut ::core::option::Option<IDebugHostTypeSignature>, wildcardmatches: *mut ::core::option::Option<IDebugHostSymbolEnumerator>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), r#type.into_param().abi(), ::core::mem::transmute(datamodel), ::core::mem::transmute(typesignature), ::core::mem::transmute(wildcardmatches)).ok()
}
pub unsafe fn RegisterModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, typesignature: Param0, datamodel: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), datamodel.into_param().abi()).ok()
}
pub unsafe fn UnregisterModelForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, datamodel: Param0, typesignature: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), typesignature.into_param().abi()).ok()
}
pub unsafe fn RegisterExtensionForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, typesignature: Param0, datamodel: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), datamodel.into_param().abi()).ok()
}
pub unsafe fn UnregisterExtensionForTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, datamodel: Param0, typesignature: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), datamodel.into_param().abi(), typesignature.into_param().abi()).ok()
}
pub unsafe fn CreateMetadataStore<'a, Param0: ::windows::core::IntoParam<'a, IKeyStore>>(&self, parentstore: Param0) -> ::windows::core::Result<IKeyStore> {
let mut result__: <IKeyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), parentstore.into_param().abi(), &mut result__).from_abi::<IKeyStore>(result__)
}
pub unsafe fn GetRootNamespace(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RegisterNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, modelname: Param0, modeobject: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), modelname.into_param().abi(), modeobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnregisterNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, modelname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), modelname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AcquireNamedModel<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, modelname: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), modelname.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AcquireSubNamespace<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, IKeyStore>>(&self, modelname: Param0, subnamespacemodelname: Param1, accessname: Param2, metadata: Param3) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), modelname.into_param().abi(), subnamespacemodelname.into_param().abi(), accessname.into_param().abi(), metadata.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateTypedIntrinsicObjectEx<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, context: Param0, intrinsicdata: *const super::super::Com::VARIANT, r#type: Param2) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), context.into_param().abi(), ::core::mem::transmute(intrinsicdata), r#type.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelManager2 {
type Vtable = IDataModelManager2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf412c5ea_2284_4622_a660_a697160d3312);
}
impl ::core::convert::From<IDataModelManager2> for ::windows::core::IUnknown {
fn from(value: IDataModelManager2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelManager2> for ::windows::core::IUnknown {
fn from(value: &IDataModelManager2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelManager2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelManager2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDataModelManager2> for IDataModelManager {
fn from(value: IDataModelManager2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDataModelManager2> for IDataModelManager {
fn from(value: &IDataModelManager2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDataModelManager> for IDataModelManager2 {
fn into_param(self) -> ::windows::core::Param<'a, IDataModelManager> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDataModelManager> for &IDataModelManager2 {
fn into_param(self) -> ::windows::core::Param<'a, IDataModelManager> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelManager2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrerror: ::windows::core::HRESULT, pwszmessage: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, objectlocation: Location, objecttype: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, objectlocation: Location, objecttype: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectkind: ModelObjectKind, intrinsicdata: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, intrinsicdata: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, r#type: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::windows::core::RawPtr, datamodel: *mut ::windows::core::RawPtr, typesignature: *mut ::windows::core::RawPtr, wildcardmatches: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodel: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parentstore: ::windows::core::RawPtr, metadatastore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rootnamespace: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR, modeobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR, modelobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modelname: super::super::super::Foundation::PWSTR, subnamespacemodelname: super::super::super::Foundation::PWSTR, accessname: super::super::super::Foundation::PWSTR, metadata: ::windows::core::RawPtr, namespacemodelobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, intrinsicdata: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, r#type: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelNameBinder(pub ::windows::core::IUnknown);
impl IDataModelNameBinder {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BindValue<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, contextobject: Param0, name: Param1, value: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(value), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn BindReference<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, contextobject: Param0, name: Param1, reference: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(reference), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn EnumerateValues<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
pub unsafe fn EnumerateReferences<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelNameBinder {
type Vtable = IDataModelNameBinder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaf352b7b_8292_4c01_b360_2dc3696c65e7);
}
impl ::core::convert::From<IDataModelNameBinder> for ::windows::core::IUnknown {
fn from(value: IDataModelNameBinder) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelNameBinder> for ::windows::core::IUnknown {
fn from(value: &IDataModelNameBinder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelNameBinder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelNameBinder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelNameBinder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, value: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, reference: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScript(pub ::windows::core::IUnknown);
impl IDataModelScript {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Rename<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, scriptname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), scriptname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Populate<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::IStream>>(&self, contentstream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), contentstream.into_param().abi()).ok()
}
pub unsafe fn Execute<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn Unlink(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn IsInvocable(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn InvokeMain<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScript {
type Vtable = IDataModelScript_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b4d30fc_b14a_49f8_8d87_d9a1480c97f7);
}
impl ::core::convert::From<IDataModelScript> for ::windows::core::IUnknown {
fn from(value: IDataModelScript) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScript> for ::windows::core::IUnknown {
fn from(value: &IDataModelScript) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScript_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contentstream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isinvocable: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptClient(pub ::windows::core::IUnknown);
impl IDataModelScriptClient {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReportError<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, errclass: ErrorClass, hrfail: ::windows::core::HRESULT, message: Param2, line: u32, position: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(errclass), ::core::mem::transmute(hrfail), message.into_param().abi(), ::core::mem::transmute(line), ::core::mem::transmute(position)).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptClient {
type Vtable = IDataModelScriptClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3b362b0e_89f0_46c6_a663_dfdc95194aef);
}
impl ::core::convert::From<IDataModelScriptClient> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptClient> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, errclass: ErrorClass, hrfail: ::windows::core::HRESULT, message: super::super::super::Foundation::PWSTR, line: u32, position: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebug(pub ::windows::core::IUnknown);
impl IDataModelScriptDebug {
pub unsafe fn GetDebugState(&self) -> ScriptDebugState {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentPosition(&self, currentposition: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(currentposition), ::core::mem::transmute(positionspanend), ::core::mem::transmute(linetext)).ok()
}
pub unsafe fn GetStack(&self) -> ::windows::core::Result<IDataModelScriptDebugStack> {
let mut result__: <IDataModelScriptDebugStack as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugStack>(result__)
}
pub unsafe fn SetBreakpoint(&self, lineposition: u32, columnposition: u32) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(lineposition), ::core::mem::transmute(columnposition), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
pub unsafe fn FindBreakpointById(&self, breakpointid: u64) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(breakpointid), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
pub unsafe fn EnumerateBreakpoints(&self) -> ::windows::core::Result<IDataModelScriptDebugBreakpointEnumerator> {
let mut result__: <IDataModelScriptDebugBreakpointEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugBreakpointEnumerator>(result__)
}
pub unsafe fn GetEventFilter(&self, eventfilter: ScriptDebugEventFilter) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventfilter), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn SetEventFilter(&self, eventfilter: ScriptDebugEventFilter, isbreakenabled: u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventfilter), ::core::mem::transmute(isbreakenabled)).ok()
}
pub unsafe fn StartDebugging<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptDebugClient>>(&self, debugclient: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), debugclient.into_param().abi()).ok()
}
pub unsafe fn StopDebugging<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptDebugClient>>(&self, debugclient: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), debugclient.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebug {
type Vtable = IDataModelScriptDebug_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xde8e0945_9750_4471_ab76_a8f79d6ec350);
}
impl ::core::convert::From<IDataModelScriptDebug> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebug) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebug> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebug) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebug_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ScriptDebugState,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, currentposition: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stack: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lineposition: u32, columnposition: u32, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breakpointid: u64, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breakpointenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventfilter: ScriptDebugEventFilter, isbreakenabled: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventfilter: ScriptDebugEventFilter, isbreakenabled: u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, debugclient: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, debugclient: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebug2(pub ::windows::core::IUnknown);
impl IDataModelScriptDebug2 {
pub unsafe fn GetDebugState(&self) -> ScriptDebugState {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentPosition(&self, currentposition: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(currentposition), ::core::mem::transmute(positionspanend), ::core::mem::transmute(linetext)).ok()
}
pub unsafe fn GetStack(&self) -> ::windows::core::Result<IDataModelScriptDebugStack> {
let mut result__: <IDataModelScriptDebugStack as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugStack>(result__)
}
pub unsafe fn SetBreakpoint(&self, lineposition: u32, columnposition: u32) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(lineposition), ::core::mem::transmute(columnposition), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
pub unsafe fn FindBreakpointById(&self, breakpointid: u64) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(breakpointid), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
pub unsafe fn EnumerateBreakpoints(&self) -> ::windows::core::Result<IDataModelScriptDebugBreakpointEnumerator> {
let mut result__: <IDataModelScriptDebugBreakpointEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugBreakpointEnumerator>(result__)
}
pub unsafe fn GetEventFilter(&self, eventfilter: ScriptDebugEventFilter) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventfilter), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn SetEventFilter(&self, eventfilter: ScriptDebugEventFilter, isbreakenabled: u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventfilter), ::core::mem::transmute(isbreakenabled)).ok()
}
pub unsafe fn StartDebugging<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptDebugClient>>(&self, debugclient: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), debugclient.into_param().abi()).ok()
}
pub unsafe fn StopDebugging<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptDebugClient>>(&self, debugclient: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), debugclient.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetBreakpointAtFunction<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, functionname: Param0) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), functionname.into_param().abi(), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebug2 {
type Vtable = IDataModelScriptDebug2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcbb10ed3_839e_426c_9243_e23535c1ae1a);
}
impl ::core::convert::From<IDataModelScriptDebug2> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebug2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebug2> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebug2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebug2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebug2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDataModelScriptDebug2> for IDataModelScriptDebug {
fn from(value: IDataModelScriptDebug2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDataModelScriptDebug2> for IDataModelScriptDebug {
fn from(value: &IDataModelScriptDebug2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDataModelScriptDebug> for IDataModelScriptDebug2 {
fn into_param(self) -> ::windows::core::Param<'a, IDataModelScriptDebug> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDataModelScriptDebug> for &IDataModelScriptDebug2 {
fn into_param(self) -> ::windows::core::Param<'a, IDataModelScriptDebug> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebug2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ScriptDebugState,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, currentposition: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stack: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lineposition: u32, columnposition: u32, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breakpointid: u64, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breakpointenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventfilter: ScriptDebugEventFilter, isbreakenabled: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventfilter: ScriptDebugEventFilter, isbreakenabled: u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, debugclient: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, debugclient: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, functionname: super::super::super::Foundation::PWSTR, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugBreakpoint(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugBreakpoint {
pub unsafe fn GetId(&self) -> u64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn IsEnabled(&self) -> bool {
::core::mem::transmute((::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Enable(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Disable(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)))
}
pub unsafe fn Remove(&self) {
::core::mem::transmute((::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPosition(&self, position: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(position), ::core::mem::transmute(positionspanend), ::core::mem::transmute(linetext)).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugBreakpoint {
type Vtable = IDataModelScriptDebugBreakpoint_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6bb27b35_02e6_47cb_90a0_5371244032de);
}
impl ::core::convert::From<IDataModelScriptDebugBreakpoint> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugBreakpoint) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugBreakpoint> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugBreakpoint) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugBreakpoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugBreakpoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugBreakpoint_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> bool,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
pub unsafe extern "system" fn(this: ::windows::core::RawPtr),
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugBreakpointEnumerator(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugBreakpointEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetNext(&self) -> ::windows::core::Result<IDataModelScriptDebugBreakpoint> {
let mut result__: <IDataModelScriptDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugBreakpoint>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugBreakpointEnumerator {
type Vtable = IDataModelScriptDebugBreakpointEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x39484a75_b4f3_4799_86da_691afa57b299);
}
impl ::core::convert::From<IDataModelScriptDebugBreakpointEnumerator> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugBreakpointEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugBreakpointEnumerator> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugBreakpointEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugBreakpointEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugBreakpointEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugBreakpointEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugClient(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugClient {
pub unsafe fn NotifyDebugEvent<'a, Param1: ::windows::core::IntoParam<'a, IDataModelScript>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, peventinfo: *const ScriptDebugEventInformation, pscript: Param1, peventdataobject: Param2, resumeeventkind: *mut ScriptExecutionKind) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(peventinfo), pscript.into_param().abi(), peventdataobject.into_param().abi(), ::core::mem::transmute(resumeeventkind)).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugClient {
type Vtable = IDataModelScriptDebugClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53159b6d_d4c4_471b_a863_5b110ca800ca);
}
impl ::core::convert::From<IDataModelScriptDebugClient> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugClient> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peventinfo: *const ScriptDebugEventInformation, pscript: ::windows::core::RawPtr, peventdataobject: ::windows::core::RawPtr, resumeeventkind: *mut ScriptExecutionKind) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugStack(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugStack {
pub unsafe fn GetFrameCount(&self) -> u64 {
::core::mem::transmute((::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetStackFrame(&self, framenumber: u64) -> ::windows::core::Result<IDataModelScriptDebugStackFrame> {
let mut result__: <IDataModelScriptDebugStackFrame as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(framenumber), &mut result__).from_abi::<IDataModelScriptDebugStackFrame>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugStack {
type Vtable = IDataModelScriptDebugStack_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x051364dd_e449_443e_9762_fe578f4a5473);
}
impl ::core::convert::From<IDataModelScriptDebugStack> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugStack) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugStack> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugStack) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugStack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugStack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugStack_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u64,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, framenumber: u64, stackframe: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugStackFrame(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugStackFrame {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPosition(&self, position: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(position), ::core::mem::transmute(positionspanend), ::core::mem::transmute(linetext)).ok()
}
pub unsafe fn IsTransitionPoint(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetTransition(&self, transitionscript: *mut ::core::option::Option<IDataModelScript>, istransitioncontiguous: *mut bool) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(transitionscript), ::core::mem::transmute(istransitioncontiguous)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszexpression: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pwszexpression.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn EnumerateLocals(&self) -> ::windows::core::Result<IDataModelScriptDebugVariableSetEnumerator> {
let mut result__: <IDataModelScriptDebugVariableSetEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugVariableSetEnumerator>(result__)
}
pub unsafe fn EnumerateArguments(&self) -> ::windows::core::Result<IDataModelScriptDebugVariableSetEnumerator> {
let mut result__: <IDataModelScriptDebugVariableSetEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptDebugVariableSetEnumerator>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugStackFrame {
type Vtable = IDataModelScriptDebugStackFrame_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdec6ed5e_6360_4941_ab4c_a26409de4f82);
}
impl ::core::convert::From<IDataModelScriptDebugStackFrame> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugStackFrame) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugStackFrame> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugStackFrame) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugStackFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugStackFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugStackFrame_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: *mut ScriptDebugPosition, positionspanend: *mut ScriptDebugPosition, linetext: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, istransitionpoint: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, transitionscript: *mut ::windows::core::RawPtr, istransitioncontiguous: *mut bool) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszexpression: super::super::super::Foundation::PWSTR, ppresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, variablesenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, variablesenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptDebugVariableSetEnumerator(pub ::windows::core::IUnknown);
impl IDataModelScriptDebugVariableSetEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNext(&self, variablename: *mut super::super::super::Foundation::BSTR, variablevalue: *mut ::core::option::Option<IModelObject>, variablemetadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(variablename), ::core::mem::transmute(variablevalue), ::core::mem::transmute(variablemetadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptDebugVariableSetEnumerator {
type Vtable = IDataModelScriptDebugVariableSetEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f9feed7_d045_4ac3_98a8_a98942cf6a35);
}
impl ::core::convert::From<IDataModelScriptDebugVariableSetEnumerator> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptDebugVariableSetEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptDebugVariableSetEnumerator> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptDebugVariableSetEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptDebugVariableSetEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptDebugVariableSetEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptDebugVariableSetEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, variablename: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, variablevalue: *mut ::windows::core::RawPtr, variablemetadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptHostContext(pub ::windows::core::IUnknown);
impl IDataModelScriptHostContext {
pub unsafe fn NotifyScriptChange<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScript>>(&self, script: Param0, changekind: ScriptChangeKind) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), script.into_param().abi(), ::core::mem::transmute(changekind)).ok()
}
pub unsafe fn GetNamespaceObject(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptHostContext {
type Vtable = IDataModelScriptHostContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x014d366a_1f23_4981_9219_b2db8b402054);
}
impl ::core::convert::From<IDataModelScriptHostContext> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptHostContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptHostContext> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptHostContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptHostContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptHostContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptHostContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, script: ::windows::core::RawPtr, changekind: ScriptChangeKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, namespaceobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptManager(pub ::windows::core::IUnknown);
impl IDataModelScriptManager {
pub unsafe fn GetDefaultNameBinder(&self) -> ::windows::core::Result<IDataModelNameBinder> {
let mut result__: <IDataModelNameBinder as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelNameBinder>(result__)
}
pub unsafe fn RegisterScriptProvider<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptProvider>>(&self, provider: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), provider.into_param().abi()).ok()
}
pub unsafe fn UnregisterScriptProvider<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScriptProvider>>(&self, provider: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), provider.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindProviderForScriptType<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, scripttype: Param0) -> ::windows::core::Result<IDataModelScriptProvider> {
let mut result__: <IDataModelScriptProvider as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), scripttype.into_param().abi(), &mut result__).from_abi::<IDataModelScriptProvider>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindProviderForScriptExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, scriptextension: Param0) -> ::windows::core::Result<IDataModelScriptProvider> {
let mut result__: <IDataModelScriptProvider as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), scriptextension.into_param().abi(), &mut result__).from_abi::<IDataModelScriptProvider>(result__)
}
pub unsafe fn EnumerateScriptProviders(&self) -> ::windows::core::Result<IDataModelScriptProviderEnumerator> {
let mut result__: <IDataModelScriptProviderEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptProviderEnumerator>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptManager {
type Vtable = IDataModelScriptManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6fd11e33_e5ad_410b_8011_68c6bc4bf80d);
}
impl ::core::convert::From<IDataModelScriptManager> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptManager> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppnamebinder: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, provider: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, provider: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scripttype: super::super::super::Foundation::PWSTR, provider: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, scriptextension: super::super::super::Foundation::PWSTR, provider: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptProvider(pub ::windows::core::IUnknown);
impl IDataModelScriptProvider {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtension(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn CreateScript(&self) -> ::windows::core::Result<IDataModelScript> {
let mut result__: <IDataModelScript as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScript>(result__)
}
pub unsafe fn GetDefaultTemplateContent(&self) -> ::windows::core::Result<IDataModelScriptTemplate> {
let mut result__: <IDataModelScriptTemplate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptTemplate>(result__)
}
pub unsafe fn EnumerateTemplates(&self) -> ::windows::core::Result<IDataModelScriptTemplateEnumerator> {
let mut result__: <IDataModelScriptTemplateEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptTemplateEnumerator>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptProvider {
type Vtable = IDataModelScriptProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x513461e0_4fca_48ce_8658_32f3e2056f3b);
}
impl ::core::convert::From<IDataModelScriptProvider> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptProvider> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, extension: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, script: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, templatecontent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptProviderEnumerator(pub ::windows::core::IUnknown);
impl IDataModelScriptProviderEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetNext(&self) -> ::windows::core::Result<IDataModelScriptProvider> {
let mut result__: <IDataModelScriptProvider as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptProvider>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptProviderEnumerator {
type Vtable = IDataModelScriptProviderEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95ba00e2_704a_4fe2_a8f1_a7e7d8fb0941);
}
impl ::core::convert::From<IDataModelScriptProviderEnumerator> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptProviderEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptProviderEnumerator> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptProviderEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptProviderEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptProviderEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptProviderEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, provider: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptTemplate(pub ::windows::core::IUnknown);
impl IDataModelScriptTemplate {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetContent(&self) -> ::windows::core::Result<super::super::Com::IStream> {
let mut result__: <super::super::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::IStream>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptTemplate {
type Vtable = IDataModelScriptTemplate_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1303dec4_fa3b_4f1b_9224_b953d16babb5);
}
impl ::core::convert::From<IDataModelScriptTemplate> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptTemplate) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptTemplate> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptTemplate) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptTemplate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptTemplate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptTemplate_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, templatename: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, templatedescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contentstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDataModelScriptTemplateEnumerator(pub ::windows::core::IUnknown);
impl IDataModelScriptTemplateEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetNext(&self) -> ::windows::core::Result<IDataModelScriptTemplate> {
let mut result__: <IDataModelScriptTemplate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDataModelScriptTemplate>(result__)
}
}
unsafe impl ::windows::core::Interface for IDataModelScriptTemplateEnumerator {
type Vtable = IDataModelScriptTemplateEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x69ce6ae2_2268_4e6f_b062_20ce62bfe677);
}
impl ::core::convert::From<IDataModelScriptTemplateEnumerator> for ::windows::core::IUnknown {
fn from(value: IDataModelScriptTemplateEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDataModelScriptTemplateEnumerator> for ::windows::core::IUnknown {
fn from(value: &IDataModelScriptTemplateEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDataModelScriptTemplateEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDataModelScriptTemplateEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDataModelScriptTemplateEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, templatecontent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAdvanced(pub ::windows::core::IUnknown);
impl IDebugAdvanced {
pub unsafe fn GetThreadContext(&self, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SetThreadContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAdvanced {
type Vtable = IDebugAdvanced_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2df5f53_071f_47bd_9de6_5734c3fed689);
}
impl ::core::convert::From<IDebugAdvanced> for ::windows::core::IUnknown {
fn from(value: IDebugAdvanced) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAdvanced> for ::windows::core::IUnknown {
fn from(value: &IDebugAdvanced) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAdvanced {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAdvanced {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAdvanced_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAdvanced2(pub ::windows::core::IUnknown);
impl IDebugAdvanced2 {
pub unsafe fn GetThreadContext(&self, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SetThreadContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn Request(&self, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(request), ::core::mem::transmute(inbuffer), ::core::mem::transmute(inbuffersize), ::core::mem::transmute(outbuffer), ::core::mem::transmute(outbuffersize), ::core::mem::transmute(outsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileInformation<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, which: u32, sourcefile: Param1, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), sourcefile.into_param().abi(), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileAndToken<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, modaddr: u64, file: Param2, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startelement),
::core::mem::transmute(modaddr),
file.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(filetoken),
::core::mem::transmute(filetokensize),
::core::mem::transmute(foundelement),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(foundsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
)
.ok()
}
pub unsafe fn GetSystemObjectInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAdvanced2 {
type Vtable = IDebugAdvanced2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x716d14c9_119b_4ba5_af1f_0890e672416a);
}
impl ::core::convert::From<IDebugAdvanced2> for ::windows::core::IUnknown {
fn from(value: IDebugAdvanced2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAdvanced2> for ::windows::core::IUnknown {
fn from(value: &IDebugAdvanced2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAdvanced2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAdvanced2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAdvanced2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, sourcefile: super::super::super::Foundation::PSTR, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, modaddr: u64, file: super::super::super::Foundation::PSTR, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAdvanced3(pub ::windows::core::IUnknown);
impl IDebugAdvanced3 {
pub unsafe fn GetThreadContext(&self, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SetThreadContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn Request(&self, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(request), ::core::mem::transmute(inbuffer), ::core::mem::transmute(inbuffersize), ::core::mem::transmute(outbuffer), ::core::mem::transmute(outbuffersize), ::core::mem::transmute(outsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileInformation<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, which: u32, sourcefile: Param1, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), sourcefile.into_param().abi(), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileAndToken<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, modaddr: u64, file: Param2, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startelement),
::core::mem::transmute(modaddr),
file.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(filetoken),
::core::mem::transmute(filetokensize),
::core::mem::transmute(foundelement),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(foundsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
)
.ok()
}
pub unsafe fn GetSystemObjectInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileInformationWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, which: u32, sourcefile: Param1, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), sourcefile.into_param().abi(), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileAndTokenWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, startelement: u32, modaddr: u64, file: Param2, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startelement),
::core::mem::transmute(modaddr),
file.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(filetoken),
::core::mem::transmute(filetokensize),
::core::mem::transmute(foundelement),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(foundsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformationWide(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAdvanced3 {
type Vtable = IDebugAdvanced3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcba4abb4_84c4_444d_87ca_a04e13286739);
}
impl ::core::convert::From<IDebugAdvanced3> for ::windows::core::IUnknown {
fn from(value: IDebugAdvanced3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAdvanced3> for ::windows::core::IUnknown {
fn from(value: &IDebugAdvanced3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAdvanced3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAdvanced3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAdvanced3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, sourcefile: super::super::super::Foundation::PSTR, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, modaddr: u64, file: super::super::super::Foundation::PSTR, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, sourcefile: super::super::super::Foundation::PWSTR, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, modaddr: u64, file: super::super::super::Foundation::PWSTR, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAdvanced4(pub ::windows::core::IUnknown);
impl IDebugAdvanced4 {
pub unsafe fn GetThreadContext(&self, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SetThreadContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn Request(&self, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(request), ::core::mem::transmute(inbuffer), ::core::mem::transmute(inbuffersize), ::core::mem::transmute(outbuffer), ::core::mem::transmute(outbuffersize), ::core::mem::transmute(outsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileInformation<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, which: u32, sourcefile: Param1, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), sourcefile.into_param().abi(), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileAndToken<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, modaddr: u64, file: Param2, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startelement),
::core::mem::transmute(modaddr),
file.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(filetoken),
::core::mem::transmute(filetokensize),
::core::mem::transmute(foundelement),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(foundsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
)
.ok()
}
pub unsafe fn GetSystemObjectInformation(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileInformationWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, which: u32, sourcefile: Param1, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), sourcefile.into_param().abi(), ::core::mem::transmute(arg64), ::core::mem::transmute(arg32), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileAndTokenWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, startelement: u32, modaddr: u64, file: Param2, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startelement),
::core::mem::transmute(modaddr),
file.into_param().abi(),
::core::mem::transmute(flags),
::core::mem::transmute(filetoken),
::core::mem::transmute(filetokensize),
::core::mem::transmute(foundelement),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(foundsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformationWide(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolInformationWideEx(&self, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32, pinfoex: *mut SYMBOL_INFO_EX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(
::core::mem::transmute_copy(self),
::core::mem::transmute(which),
::core::mem::transmute(arg64),
::core::mem::transmute(arg32),
::core::mem::transmute(buffer),
::core::mem::transmute(buffersize),
::core::mem::transmute(infosize),
::core::mem::transmute(stringbuffer),
::core::mem::transmute(stringbuffersize),
::core::mem::transmute(stringsize),
::core::mem::transmute(pinfoex),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAdvanced4 {
type Vtable = IDebugAdvanced4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd1069067_2a65_4bf0_ae97_76184b67856b);
}
impl ::core::convert::From<IDebugAdvanced4> for ::windows::core::IUnknown {
fn from(value: IDebugAdvanced4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAdvanced4> for ::windows::core::IUnknown {
fn from(value: &IDebugAdvanced4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAdvanced4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAdvanced4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAdvanced4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, request: u32, inbuffer: *const ::core::ffi::c_void, inbuffersize: u32, outbuffer: *mut ::core::ffi::c_void, outbuffersize: u32, outsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, sourcefile: super::super::super::Foundation::PSTR, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, modaddr: u64, file: super::super::super::Foundation::PSTR, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, sourcefile: super::super::super::Foundation::PWSTR, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, modaddr: u64, file: super::super::super::Foundation::PWSTR, flags: u32, filetoken: *const ::core::ffi::c_void, filetokensize: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, arg64: u64, arg32: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32, stringbuffer: super::super::super::Foundation::PWSTR, stringbuffersize: u32, stringsize: *mut u32, pinfoex: *mut SYMBOL_INFO_EX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplication11032(pub ::windows::core::IUnknown);
impl IDebugApplication11032 {
pub unsafe fn SetDebuggerOptions(&self, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), ::core::mem::transmute(value)).ok()
}
pub unsafe fn GetCurrentDebuggerOptions(&self) -> ::windows::core::Result<SCRIPT_DEBUGGER_OPTIONS> {
let mut result__: <SCRIPT_DEBUGGER_OPTIONS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPT_DEBUGGER_OPTIONS>(result__)
}
pub unsafe fn GetMainThread(&self) -> ::windows::core::Result<IRemoteDebugApplicationThread> {
let mut result__: <IRemoteDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplicationThread>(result__)
}
pub unsafe fn SynchronousCallInMainThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn AsynchronousCallInMainThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallableWaitForHandles(&self, handlecount: u32, phandles: *const super::super::super::Foundation::HANDLE) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(handlecount), ::core::mem::transmute(phandles), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugApplication11032 {
type Vtable = IDebugApplication11032_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbdb3b5de_89f2_4e11_84a5_97445f941c7d);
}
impl ::core::convert::From<IDebugApplication11032> for ::windows::core::IUnknown {
fn from(value: IDebugApplication11032) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplication11032> for ::windows::core::IUnknown {
fn from(value: &IDebugApplication11032) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplication11032 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplication11032 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplication11032> for IRemoteDebugApplication110 {
fn from(value: IDebugApplication11032) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplication11032> for IRemoteDebugApplication110 {
fn from(value: &IDebugApplication11032) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication110> for IDebugApplication11032 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication110> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication110> for &IDebugApplication11032 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication110> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplication11032_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcurrentoptions: *mut SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppthread: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handlecount: u32, phandles: *const super::super::super::Foundation::HANDLE, pindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplication11064(pub ::windows::core::IUnknown);
impl IDebugApplication11064 {
pub unsafe fn SetDebuggerOptions(&self, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), ::core::mem::transmute(value)).ok()
}
pub unsafe fn GetCurrentDebuggerOptions(&self) -> ::windows::core::Result<SCRIPT_DEBUGGER_OPTIONS> {
let mut result__: <SCRIPT_DEBUGGER_OPTIONS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPT_DEBUGGER_OPTIONS>(result__)
}
pub unsafe fn GetMainThread(&self) -> ::windows::core::Result<IRemoteDebugApplicationThread> {
let mut result__: <IRemoteDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplicationThread>(result__)
}
pub unsafe fn SynchronousCallInMainThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall64>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn AsynchronousCallInMainThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall64>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallableWaitForHandles(&self, handlecount: u32, phandles: *const super::super::super::Foundation::HANDLE) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(handlecount), ::core::mem::transmute(phandles), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugApplication11064 {
type Vtable = IDebugApplication11064_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2039d958_4eeb_496a_87bb_2e5201eadeef);
}
impl ::core::convert::From<IDebugApplication11064> for ::windows::core::IUnknown {
fn from(value: IDebugApplication11064) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplication11064> for ::windows::core::IUnknown {
fn from(value: &IDebugApplication11064) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplication11064 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplication11064 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplication11064> for IRemoteDebugApplication110 {
fn from(value: IDebugApplication11064) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplication11064> for IRemoteDebugApplication110 {
fn from(value: &IDebugApplication11064) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication110> for IDebugApplication11064 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication110> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication110> for &IDebugApplication11064 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication110> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplication11064_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcurrentoptions: *mut SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppthread: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handlecount: u32, phandles: *const super::super::super::Foundation::HANDLE, pindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplication32(pub ::windows::core::IUnknown);
impl IDebugApplication32 {
pub unsafe fn ResumeFromBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prptfocus: Param0, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), prptfocus.into_param().abi(), ::core::mem::transmute(bra), ::core::mem::transmute(era)).ok()
}
pub unsafe fn CauseBreak(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ConnectDebugger<'a, Param0: ::windows::core::IntoParam<'a, IApplicationDebugger>>(&self, pad: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pad.into_param().abi()).ok()
}
pub unsafe fn DisconnectDebugger(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetDebugger(&self) -> ::windows::core::Result<IApplicationDebugger> {
let mut result__: <IApplicationDebugger as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IApplicationDebugger>(result__)
}
pub unsafe fn CreateInstanceAtApplication<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, rclsid: *const ::windows::core::GUID, punkouter: Param1, dwclscontext: u32, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(rclsid), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn QueryAlive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumThreads(&self) -> ::windows::core::Result<IEnumRemoteDebugApplicationThreads> {
let mut result__: <IEnumRemoteDebugApplicationThreads as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplicationThreads>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetRootNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn EnumGlobalExpressionContexts(&self) -> ::windows::core::Result<IEnumDebugExpressionContexts> {
let mut result__: <IEnumDebugExpressionContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExpressionContexts>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pstrname.into_param().abi()).ok()
}
pub unsafe fn StepOutComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DebugOutput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstr: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pstr.into_param().abi()).ok()
}
pub unsafe fn StartDebugSession(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn HandleBreakPoint(&self, br: BREAKREASON) -> ::windows::core::Result<BREAKRESUME_ACTION> {
let mut result__: <BREAKRESUME_ACTION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(br), &mut result__).from_abi::<BREAKRESUME_ACTION>(result__)
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetBreakFlags(&self, pabf: *mut u32, pprdatsteppingthread: *mut ::core::option::Option<IRemoteDebugApplicationThread>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(pabf), ::core::mem::transmute(pprdatsteppingthread)).ok()
}
pub unsafe fn GetCurrentThread(&self) -> ::windows::core::Result<IDebugApplicationThread> {
let mut result__: <IDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationThread>(result__)
}
pub unsafe fn CreateAsyncDebugOperation<'a, Param0: ::windows::core::IntoParam<'a, IDebugSyncOperation>>(&self, psdo: Param0) -> ::windows::core::Result<IDebugAsyncOperation> {
let mut result__: <IDebugAsyncOperation as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), psdo.into_param().abi(), &mut result__).from_abi::<IDebugAsyncOperation>(result__)
}
pub unsafe fn AddStackFrameSniffer<'a, Param0: ::windows::core::IntoParam<'a, IDebugStackFrameSniffer>>(&self, pdsfs: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pdsfs.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveStackFrameSniffer(&self, dwcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie)).ok()
}
pub unsafe fn QueryCurrentThreadIsDebuggerThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SynchronousCallInDebuggerThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pptc: Param0, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn CreateApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn FireDebuggerEvent<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, riid: *const ::windows::core::GUID, punk: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), punk.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HandleRuntimeError<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>, Param1: ::windows::core::IntoParam<'a, IActiveScriptSite>>(&self, perrordebug: Param0, pscriptsite: Param1, pbra: *mut BREAKRESUME_ACTION, perra: *mut ERRORRESUMEACTION, pfcallonscripterror: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), perrordebug.into_param().abi(), pscriptsite.into_param().abi(), ::core::mem::transmute(pbra), ::core::mem::transmute(perra), ::core::mem::transmute(pfcallonscripterror)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FCanJitDebug(&self) -> super::super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FIsAutoJitDebugEnabled(&self) -> super::super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self)))
}
pub unsafe fn AddGlobalExpressionContextProvider<'a, Param0: ::windows::core::IntoParam<'a, IProvideExpressionContexts>>(&self, pdsfs: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdsfs.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveGlobalExpressionContextProvider(&self, dwcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplication32 {
type Vtable = IDebugApplication32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c32_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugApplication32> for ::windows::core::IUnknown {
fn from(value: IDebugApplication32) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplication32> for ::windows::core::IUnknown {
fn from(value: &IDebugApplication32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplication32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplication32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplication32> for IRemoteDebugApplication {
fn from(value: IDebugApplication32) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplication32> for IRemoteDebugApplication {
fn from(value: &IDebugApplication32) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication> for IDebugApplication32 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication> for &IDebugApplication32 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplication32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prptfocus: ::windows::core::RawPtr, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rclsid: *const ::windows::core::GUID, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperdat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdanroot: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedec: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstr: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, br: BREAKREASON, pbra: *mut BREAKRESUME_ACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pabf: *mut u32, pprdatsteppingthread: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psdo: ::windows::core::RawPtr, ppado: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdsfs: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdannew: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, perrordebug: ::windows::core::RawPtr, pscriptsite: ::windows::core::RawPtr, pbra: *mut BREAKRESUME_ACTION, perra: *mut ERRORRESUMEACTION, pfcallonscripterror: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdsfs: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplication64(pub ::windows::core::IUnknown);
impl IDebugApplication64 {
pub unsafe fn ResumeFromBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prptfocus: Param0, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), prptfocus.into_param().abi(), ::core::mem::transmute(bra), ::core::mem::transmute(era)).ok()
}
pub unsafe fn CauseBreak(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ConnectDebugger<'a, Param0: ::windows::core::IntoParam<'a, IApplicationDebugger>>(&self, pad: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pad.into_param().abi()).ok()
}
pub unsafe fn DisconnectDebugger(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetDebugger(&self) -> ::windows::core::Result<IApplicationDebugger> {
let mut result__: <IApplicationDebugger as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IApplicationDebugger>(result__)
}
pub unsafe fn CreateInstanceAtApplication<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, rclsid: *const ::windows::core::GUID, punkouter: Param1, dwclscontext: u32, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(rclsid), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn QueryAlive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumThreads(&self) -> ::windows::core::Result<IEnumRemoteDebugApplicationThreads> {
let mut result__: <IEnumRemoteDebugApplicationThreads as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplicationThreads>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetRootNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn EnumGlobalExpressionContexts(&self) -> ::windows::core::Result<IEnumDebugExpressionContexts> {
let mut result__: <IEnumDebugExpressionContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExpressionContexts>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pstrname.into_param().abi()).ok()
}
pub unsafe fn StepOutComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DebugOutput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstr: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pstr.into_param().abi()).ok()
}
pub unsafe fn StartDebugSession(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn HandleBreakPoint(&self, br: BREAKREASON) -> ::windows::core::Result<BREAKRESUME_ACTION> {
let mut result__: <BREAKRESUME_ACTION as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(br), &mut result__).from_abi::<BREAKRESUME_ACTION>(result__)
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetBreakFlags(&self, pabf: *mut u32, pprdatsteppingthread: *mut ::core::option::Option<IRemoteDebugApplicationThread>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(pabf), ::core::mem::transmute(pprdatsteppingthread)).ok()
}
pub unsafe fn GetCurrentThread(&self) -> ::windows::core::Result<IDebugApplicationThread> {
let mut result__: <IDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationThread>(result__)
}
pub unsafe fn CreateAsyncDebugOperation<'a, Param0: ::windows::core::IntoParam<'a, IDebugSyncOperation>>(&self, psdo: Param0) -> ::windows::core::Result<IDebugAsyncOperation> {
let mut result__: <IDebugAsyncOperation as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), psdo.into_param().abi(), &mut result__).from_abi::<IDebugAsyncOperation>(result__)
}
pub unsafe fn AddStackFrameSniffer<'a, Param0: ::windows::core::IntoParam<'a, IDebugStackFrameSniffer>>(&self, pdsfs: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pdsfs.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveStackFrameSniffer(&self, dwcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie)).ok()
}
pub unsafe fn QueryCurrentThreadIsDebuggerThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SynchronousCallInDebuggerThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall64>>(&self, pptc: Param0, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn CreateApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn FireDebuggerEvent<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, riid: *const ::windows::core::GUID, punk: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), punk.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn HandleRuntimeError<'a, Param0: ::windows::core::IntoParam<'a, IActiveScriptErrorDebug>, Param1: ::windows::core::IntoParam<'a, IActiveScriptSite>>(&self, perrordebug: Param0, pscriptsite: Param1, pbra: *mut BREAKRESUME_ACTION, perra: *mut ERRORRESUMEACTION, pfcallonscripterror: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), perrordebug.into_param().abi(), pscriptsite.into_param().abi(), ::core::mem::transmute(pbra), ::core::mem::transmute(perra), ::core::mem::transmute(pfcallonscripterror)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FCanJitDebug(&self) -> super::super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FIsAutoJitDebugEnabled(&self) -> super::super::super::Foundation::BOOL {
::core::mem::transmute((::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self)))
}
pub unsafe fn AddGlobalExpressionContextProvider<'a, Param0: ::windows::core::IntoParam<'a, IProvideExpressionContexts>>(&self, pdsfs: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), pdsfs.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveGlobalExpressionContextProvider(&self, dwcookie: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplication64 {
type Vtable = IDebugApplication64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4dedc754_04c7_4f10_9e60_16a390fe6e62);
}
impl ::core::convert::From<IDebugApplication64> for ::windows::core::IUnknown {
fn from(value: IDebugApplication64) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplication64> for ::windows::core::IUnknown {
fn from(value: &IDebugApplication64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplication64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplication64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplication64> for IRemoteDebugApplication {
fn from(value: IDebugApplication64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplication64> for IRemoteDebugApplication {
fn from(value: &IDebugApplication64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication> for IDebugApplication64 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplication> for &IDebugApplication64 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplication> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplication64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prptfocus: ::windows::core::RawPtr, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rclsid: *const ::windows::core::GUID, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperdat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdanroot: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedec: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstr: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, br: BREAKREASON, pbra: *mut BREAKRESUME_ACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pabf: *mut u32, pprdatsteppingthread: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psdo: ::windows::core::RawPtr, ppado: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdsfs: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdannew: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, punk: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, perrordebug: ::windows::core::RawPtr, pscriptsite: ::windows::core::RawPtr, pbra: *mut BREAKRESUME_ACTION, perra: *mut ERRORRESUMEACTION, pfcallonscripterror: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdsfs: ::windows::core::RawPtr, pdwcookie: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationNode(pub ::windows::core::IUnknown);
impl IDebugApplicationNode {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetDocument(&self) -> ::windows::core::Result<IDebugDocument> {
let mut result__: <IDebugDocument as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugDocument>(result__)
}
pub unsafe fn EnumChildren(&self) -> ::windows::core::Result<IEnumDebugApplicationNodes> {
let mut result__: <IEnumDebugApplicationNodes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugApplicationNodes>(result__)
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn SetDocumentProvider<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentProvider>>(&self, pddp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pddp.into_param().abi()).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Attach<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, pdanparent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pdanparent.into_param().abi()).ok()
}
pub unsafe fn Detach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationNode {
type Vtable = IDebugApplicationNode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c34_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugApplicationNode> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationNode) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationNode> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationNode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplicationNode> for IDebugDocumentProvider {
fn from(value: IDebugApplicationNode) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplicationNode> for IDebugDocumentProvider {
fn from(value: &IDebugApplicationNode) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentProvider> for IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentProvider> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentProvider> for &IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentProvider> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugApplicationNode> for IDebugDocumentInfo {
fn from(value: IDebugApplicationNode) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplicationNode> for IDebugDocumentInfo {
fn from(value: &IDebugApplicationNode) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for &IDebugApplicationNode {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationNode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppssd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperddp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprddp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdanparent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationNode100(pub ::windows::core::IUnknown);
impl IDebugApplicationNode100 {
pub unsafe fn SetFilterForEventSink(&self, dwcookie: u32, filter: APPLICATION_NODE_EVENT_FILTER) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie), ::core::mem::transmute(filter)).ok()
}
pub unsafe fn GetExcludedDocuments(&self, filter: APPLICATION_NODE_EVENT_FILTER) -> ::windows::core::Result<TEXT_DOCUMENT_ARRAY> {
let mut result__: <TEXT_DOCUMENT_ARRAY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(filter), &mut result__).from_abi::<TEXT_DOCUMENT_ARRAY>(result__)
}
pub unsafe fn QueryIsChildNode<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocument>>(&self, psearchkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), psearchkey.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationNode100 {
type Vtable = IDebugApplicationNode100_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90a7734e_841b_4f77_9384_a2891e76e7e2);
}
impl ::core::convert::From<IDebugApplicationNode100> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationNode100) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationNode100> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationNode100) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationNode100 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationNode100 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationNode100_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u32, filter: APPLICATION_NODE_EVENT_FILTER) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filter: APPLICATION_NODE_EVENT_FILTER, pdocuments: *mut TEXT_DOCUMENT_ARRAY) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psearchkey: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationNodeEvents(pub ::windows::core::IUnknown);
impl IDebugApplicationNodeEvents {
pub unsafe fn onAddChild<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpchild: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), prddpchild.into_param().abi()).ok()
}
pub unsafe fn onRemoveChild<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpchild: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), prddpchild.into_param().abi()).ok()
}
pub unsafe fn onDetach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn onAttach<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplicationNode>>(&self, prddpparent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), prddpparent.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationNodeEvents {
type Vtable = IDebugApplicationNodeEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c35_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugApplicationNodeEvents> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationNodeEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationNodeEvents> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationNodeEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationNodeEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationNodeEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationNodeEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpchild: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpchild: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prddpparent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationThread(pub ::windows::core::IUnknown);
impl IDebugApplicationThread {
pub unsafe fn GetSystemThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetApplication(&self) -> ::windows::core::Result<IRemoteDebugApplication> {
let mut result__: <IRemoteDebugApplication as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplication>(result__)
}
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, pbstrdescription: *mut super::super::super::Foundation::BSTR, pbstrstate: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrdescription), ::core::mem::transmute(pbstrstate)).ok()
}
pub unsafe fn SetNextStatement<'a, Param0: ::windows::core::IntoParam<'a, IDebugStackFrame>, Param1: ::windows::core::IntoParam<'a, IDebugCodeContext>>(&self, pstackframe: Param0, pcodecontext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstackframe.into_param().abi(), pcodecontext.into_param().abi()).ok()
}
pub unsafe fn GetState(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Suspend(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSuspendCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SynchronousCallIntoThread32<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pstcb: Param0, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pstcb.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn QueryIsCurrentThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn QueryIsDebuggerThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDescription<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrdescription: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pstrdescription.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStateString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrstate: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pstrstate.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationThread {
type Vtable = IDebugApplicationThread_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c38_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugApplicationThread> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationThread) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationThread> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationThread) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplicationThread> for IRemoteDebugApplicationThread {
fn from(value: IDebugApplicationThread) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplicationThread> for IRemoteDebugApplicationThread {
fn from(value: &IDebugApplicationThread) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread> for IDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplicationThread> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread> for &IDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplicationThread> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationThread_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwthreadid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pbstrstate: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstackframe: ::windows::core::RawPtr, pcodecontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstcb: ::windows::core::RawPtr, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrdescription: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrstate: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationThread11032(pub ::windows::core::IUnknown);
impl IDebugApplicationThread11032 {
pub unsafe fn GetActiveThreadRequestCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSuspendedForBreakPoint(&self) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsThreadCallable(&self) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
pub unsafe fn AsynchronousCallIntoThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationThread11032 {
type Vtable = IDebugApplicationThread11032_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2194ac5c_6561_404a_a2e9_f57d72de3702);
}
impl ::core::convert::From<IDebugApplicationThread11032> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationThread11032) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationThread11032> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationThread11032) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationThread11032 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationThread11032 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationThread11032_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, puithreadrequests: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfissuspended: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfiscallable: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationThread11064(pub ::windows::core::IUnknown);
impl IDebugApplicationThread11064 {
pub unsafe fn GetActiveThreadRequestCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsSuspendedForBreakPoint(&self) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsThreadCallable(&self) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
pub unsafe fn AsynchronousCallIntoThread<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall64>>(&self, pptc: Param0, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pptc.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationThread11064 {
type Vtable = IDebugApplicationThread11064_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x420aa4cc_efd8_4dac_983b_47127826917d);
}
impl ::core::convert::From<IDebugApplicationThread11064> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationThread11064) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationThread11064> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationThread11064) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationThread11064 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationThread11064 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationThread11064_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, puithreadrequests: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfissuspended: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfiscallable: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptc: ::windows::core::RawPtr, dwparam1: usize, dwparam2: usize, dwparam3: usize) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationThread64(pub ::windows::core::IUnknown);
impl IDebugApplicationThread64 {
pub unsafe fn GetSystemThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetApplication(&self) -> ::windows::core::Result<IRemoteDebugApplication> {
let mut result__: <IRemoteDebugApplication as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplication>(result__)
}
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, pbstrdescription: *mut super::super::super::Foundation::BSTR, pbstrstate: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrdescription), ::core::mem::transmute(pbstrstate)).ok()
}
pub unsafe fn SetNextStatement<'a, Param0: ::windows::core::IntoParam<'a, IDebugStackFrame>, Param1: ::windows::core::IntoParam<'a, IDebugCodeContext>>(&self, pstackframe: Param0, pcodecontext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstackframe.into_param().abi(), pcodecontext.into_param().abi()).ok()
}
pub unsafe fn GetState(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Suspend(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSuspendCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SynchronousCallIntoThread32<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall32>>(&self, pstcb: Param0, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pstcb.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
pub unsafe fn QueryIsCurrentThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn QueryIsDebuggerThread(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDescription<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrdescription: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pstrdescription.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStateString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrstate: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pstrstate.into_param().abi()).ok()
}
pub unsafe fn SynchronousCallIntoThread64<'a, Param0: ::windows::core::IntoParam<'a, IDebugThreadCall64>>(&self, pstcb: Param0, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pstcb.into_param().abi(), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationThread64 {
type Vtable = IDebugApplicationThread64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9dac5886_dbad_456d_9dee_5dec39ab3dda);
}
impl ::core::convert::From<IDebugApplicationThread64> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationThread64) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationThread64> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationThread64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugApplicationThread64> for IDebugApplicationThread {
fn from(value: IDebugApplicationThread64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplicationThread64> for IDebugApplicationThread {
fn from(value: &IDebugApplicationThread64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugApplicationThread> for IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugApplicationThread> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugApplicationThread> for &IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugApplicationThread> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugApplicationThread64> for IRemoteDebugApplicationThread {
fn from(value: IDebugApplicationThread64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugApplicationThread64> for IRemoteDebugApplicationThread {
fn from(value: &IDebugApplicationThread64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread> for IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplicationThread> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread> for &IDebugApplicationThread64 {
fn into_param(self) -> ::windows::core::Param<'a, IRemoteDebugApplicationThread> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationThread64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwthreadid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pbstrstate: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstackframe: ::windows::core::RawPtr, pcodecontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstcb: ::windows::core::RawPtr, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrdescription: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrstate: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstcb: ::windows::core::RawPtr, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugApplicationThreadEvents110(pub ::windows::core::IUnknown);
impl IDebugApplicationThreadEvents110 {
pub unsafe fn OnSuspendForBreakPoint(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnResumeFromBreakPoint(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnThreadRequestComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnBeginThreadRequest(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugApplicationThreadEvents110 {
type Vtable = IDebugApplicationThreadEvents110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x84e5e468_d5da_48a8_83f4_40366429007b);
}
impl ::core::convert::From<IDebugApplicationThreadEvents110> for ::windows::core::IUnknown {
fn from(value: IDebugApplicationThreadEvents110) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugApplicationThreadEvents110> for ::windows::core::IUnknown {
fn from(value: &IDebugApplicationThreadEvents110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugApplicationThreadEvents110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugApplicationThreadEvents110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugApplicationThreadEvents110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAsyncOperation(pub ::windows::core::IUnknown);
impl IDebugAsyncOperation {
pub unsafe fn GetSyncDebugOperation(&self) -> ::windows::core::Result<IDebugSyncOperation> {
let mut result__: <IDebugSyncOperation as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSyncOperation>(result__)
}
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IDebugAsyncOperationCallBack>>(&self, padocb: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), padocb.into_param().abi()).ok()
}
pub unsafe fn Abort(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn QueryIsComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetResult(&self, phrresult: *mut ::windows::core::HRESULT, ppunkresult: *mut ::core::option::Option<::windows::core::IUnknown>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(phrresult), ::core::mem::transmute(ppunkresult)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAsyncOperation {
type Vtable = IDebugAsyncOperation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1b_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugAsyncOperation> for ::windows::core::IUnknown {
fn from(value: IDebugAsyncOperation) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAsyncOperation> for ::windows::core::IUnknown {
fn from(value: &IDebugAsyncOperation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAsyncOperation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAsyncOperation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAsyncOperation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsdo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, padocb: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phrresult: *mut ::windows::core::HRESULT, ppunkresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugAsyncOperationCallBack(pub ::windows::core::IUnknown);
impl IDebugAsyncOperationCallBack {
pub unsafe fn onComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugAsyncOperationCallBack {
type Vtable = IDebugAsyncOperationCallBack_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1c_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugAsyncOperationCallBack> for ::windows::core::IUnknown {
fn from(value: IDebugAsyncOperationCallBack) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugAsyncOperationCallBack> for ::windows::core::IUnknown {
fn from(value: &IDebugAsyncOperationCallBack) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugAsyncOperationCallBack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugAsyncOperationCallBack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugAsyncOperationCallBack_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugBreakpoint(pub ::windows::core::IUnknown);
impl IDebugBreakpoint {
pub unsafe fn GetId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetType(&self, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(breaktype), ::core::mem::transmute(proctype)).ok()
}
pub unsafe fn GetAdder(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn SetFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetDataParameters(&self, size: *mut u32, accesstype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn SetDataParameters(&self, size: u32, accesstype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn GetPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetPassCount(&self, count: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(count)).ok()
}
pub unsafe fn GetCurrentPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMatchThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetMatchThreadId(&self, thread: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(thread)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCommand(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetCommand<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, command: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetExpression(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(expressionsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOffsetExpression<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), expression.into_param().abi()).ok()
}
pub unsafe fn GetParameters(&self) -> ::windows::core::Result<DEBUG_BREAKPOINT_PARAMETERS> {
let mut result__: <DEBUG_BREAKPOINT_PARAMETERS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEBUG_BREAKPOINT_PARAMETERS>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugBreakpoint {
type Vtable = IDebugBreakpoint_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5bd9d474_5975_423a_b88b_65a8e7110e65);
}
impl ::core::convert::From<IDebugBreakpoint> for ::windows::core::IUnknown {
fn from(value: IDebugBreakpoint) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugBreakpoint> for ::windows::core::IUnknown {
fn from(value: &IDebugBreakpoint) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugBreakpoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugBreakpoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugBreakpoint_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, adder: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32, accesstype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: u32, accesstype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, thread: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugBreakpoint2(pub ::windows::core::IUnknown);
impl IDebugBreakpoint2 {
pub unsafe fn GetId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetType(&self, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(breaktype), ::core::mem::transmute(proctype)).ok()
}
pub unsafe fn GetAdder(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn SetFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetDataParameters(&self, size: *mut u32, accesstype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn SetDataParameters(&self, size: u32, accesstype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn GetPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetPassCount(&self, count: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(count)).ok()
}
pub unsafe fn GetCurrentPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMatchThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetMatchThreadId(&self, thread: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(thread)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCommand(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetCommand<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, command: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetExpression(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(expressionsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOffsetExpression<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), expression.into_param().abi()).ok()
}
pub unsafe fn GetParameters(&self) -> ::windows::core::Result<DEBUG_BREAKPOINT_PARAMETERS> {
let mut result__: <DEBUG_BREAKPOINT_PARAMETERS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEBUG_BREAKPOINT_PARAMETERS>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCommandWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetCommandWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, command: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetExpressionWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(expressionsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOffsetExpressionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), expression.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugBreakpoint2 {
type Vtable = IDebugBreakpoint2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1b278d20_79f2_426e_a3f9_c1ddf375d48e);
}
impl ::core::convert::From<IDebugBreakpoint2> for ::windows::core::IUnknown {
fn from(value: IDebugBreakpoint2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugBreakpoint2> for ::windows::core::IUnknown {
fn from(value: &IDebugBreakpoint2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugBreakpoint2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugBreakpoint2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugBreakpoint2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, adder: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32, accesstype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: u32, accesstype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, thread: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugBreakpoint3(pub ::windows::core::IUnknown);
impl IDebugBreakpoint3 {
pub unsafe fn GetId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetType(&self, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(breaktype), ::core::mem::transmute(proctype)).ok()
}
pub unsafe fn GetAdder(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn SetFlags(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetDataParameters(&self, size: *mut u32, accesstype: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn SetDataParameters(&self, size: u32, accesstype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(size), ::core::mem::transmute(accesstype)).ok()
}
pub unsafe fn GetPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetPassCount(&self, count: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(count)).ok()
}
pub unsafe fn GetCurrentPassCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetMatchThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetMatchThreadId(&self, thread: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(thread)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCommand(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetCommand<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, command: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetExpression(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(expressionsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOffsetExpression<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), expression.into_param().abi()).ok()
}
pub unsafe fn GetParameters(&self) -> ::windows::core::Result<DEBUG_BREAKPOINT_PARAMETERS> {
let mut result__: <DEBUG_BREAKPOINT_PARAMETERS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEBUG_BREAKPOINT_PARAMETERS>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCommandWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetCommandWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, command: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetExpressionWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(expressionsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOffsetExpressionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), expression.into_param().abi()).ok()
}
pub unsafe fn GetGuid(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugBreakpoint3 {
type Vtable = IDebugBreakpoint3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38f5c249_b448_43bb_9835_579d4ec02249);
}
impl ::core::convert::From<IDebugBreakpoint3> for ::windows::core::IUnknown {
fn from(value: IDebugBreakpoint3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugBreakpoint3> for ::windows::core::IUnknown {
fn from(value: &IDebugBreakpoint3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugBreakpoint3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugBreakpoint3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugBreakpoint3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, breaktype: *mut u32, proctype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, adder: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32, accesstype: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: u32, accesstype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, thread: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, expressionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient(pub ::windows::core::IUnknown);
impl IDebugClient {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient {
type Vtable = IDebugClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x27fe5639_8407_4f47_8364_ee118fb08ac8);
}
impl ::core::convert::From<IDebugClient> for ::windows::core::IUnknown {
fn from(value: IDebugClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient> for ::windows::core::IUnknown {
fn from(value: &IDebugClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient2(pub ::windows::core::IUnknown);
impl IDebugClient2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient2 {
type Vtable = IDebugClient2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xedbed635_372e_4dab_bbfe_ed0d2f63be81);
}
impl ::core::convert::From<IDebugClient2> for ::windows::core::IUnknown {
fn from(value: IDebugClient2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient2> for ::windows::core::IUnknown {
fn from(value: &IDebugClient2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient3(pub ::windows::core::IUnknown);
impl IDebugClient3 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient3 {
type Vtable = IDebugClient3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdd492d7f_71b8_4ad6_a8dc_1c887479ff91);
}
impl ::core::convert::From<IDebugClient3> for ::windows::core::IUnknown {
fn from(value: IDebugClient3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient3> for ::windows::core::IUnknown {
fn from(value: &IDebugClient3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient4(pub ::windows::core::IUnknown);
impl IDebugClient4 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, qualifier: u32, formatflags: u32, comment: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberDumpFiles(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFile(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFileWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient4 {
type Vtable = IDebugClient4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xca83c3de_5089_4cf8_93c8_d892387f2a5e);
}
impl ::core::convert::From<IDebugClient4> for ::windows::core::IUnknown {
fn from(value: IDebugClient4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient4> for ::windows::core::IUnknown {
fn from(value: &IDebugClient4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient5(pub ::windows::core::IUnknown);
impl IDebugClient5 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, qualifier: u32, formatflags: u32, comment: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberDumpFiles(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFile(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFileWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernelWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptionsWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptionsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServerWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServersWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOutputCallbacksWide(&self) -> ::windows::core::Result<IDebugOutputCallbacksWide> {
let mut result__: <IDebugOutputCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacksWide>(result__)
}
pub unsafe fn SetOutputCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefixWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentityWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentityWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacksWide(&self) -> ::windows::core::Result<IDebugEventCallbacksWide> {
let mut result__: <IDebugEventCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacksWide>(result__)
}
pub unsafe fn SetEventCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn PopOutputLinePrefix(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
pub unsafe fn GetNumberInputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOutputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberEventCallbacks(&self, eventflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockString(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockStringWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockStringWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient5 {
type Vtable = IDebugClient5_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe3acb9d7_7ec2_4f0c_a0da_e81e0cbbe628);
}
impl ::core::convert::From<IDebugClient5> for ::windows::core::IUnknown {
fn from(value: IDebugClient5) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient5> for ::windows::core::IUnknown {
fn from(value: &IDebugClient5) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient5_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PWSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PWSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventflags: u32, count: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient6(pub ::windows::core::IUnknown);
impl IDebugClient6 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, qualifier: u32, formatflags: u32, comment: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberDumpFiles(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFile(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFileWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernelWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptionsWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptionsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServerWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServersWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOutputCallbacksWide(&self) -> ::windows::core::Result<IDebugOutputCallbacksWide> {
let mut result__: <IDebugOutputCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacksWide>(result__)
}
pub unsafe fn SetOutputCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefixWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentityWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentityWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacksWide(&self) -> ::windows::core::Result<IDebugEventCallbacksWide> {
let mut result__: <IDebugEventCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacksWide>(result__)
}
pub unsafe fn SetEventCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn PopOutputLinePrefix(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
pub unsafe fn GetNumberInputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOutputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberEventCallbacks(&self, eventflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockString(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockStringWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockStringWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
pub unsafe fn SetEventContextCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventContextCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient6 {
type Vtable = IDebugClient6_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xfd28b4c5_c498_4686_a28e_62cad2154eb3);
}
impl ::core::convert::From<IDebugClient6> for ::windows::core::IUnknown {
fn from(value: IDebugClient6) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient6> for ::windows::core::IUnknown {
fn from(value: &IDebugClient6) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient6 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient6 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient6_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PWSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PWSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventflags: u32, count: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient7(pub ::windows::core::IUnknown);
impl IDebugClient7 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, qualifier: u32, formatflags: u32, comment: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberDumpFiles(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFile(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFileWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernelWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptionsWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptionsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServerWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServersWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOutputCallbacksWide(&self) -> ::windows::core::Result<IDebugOutputCallbacksWide> {
let mut result__: <IDebugOutputCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacksWide>(result__)
}
pub unsafe fn SetOutputCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefixWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentityWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentityWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacksWide(&self) -> ::windows::core::Result<IDebugEventCallbacksWide> {
let mut result__: <IDebugEventCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacksWide>(result__)
}
pub unsafe fn SetEventCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn PopOutputLinePrefix(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
pub unsafe fn GetNumberInputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOutputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberEventCallbacks(&self, eventflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockString(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockStringWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockStringWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
pub unsafe fn SetEventContextCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventContextCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn SetClientContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient7 {
type Vtable = IDebugClient7_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x13586be3_542e_481e_b1f2_8497ba74f9a9);
}
impl ::core::convert::From<IDebugClient7> for ::windows::core::IUnknown {
fn from(value: IDebugClient7) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient7> for ::windows::core::IUnknown {
fn from(value: &IDebugClient7) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient7 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient7 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient7_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PWSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PWSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventflags: u32, count: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugClient8(pub ::windows::core::IUnknown);
impl IDebugClient8 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernel<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptions(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptions<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServer<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn DisconnectProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn GetRunningProcessSystemIds(&self, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(ids), ::core::mem::transmute(count), ::core::mem::transmute(actualcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableName<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescription(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
pub unsafe fn AttachProcess(&self, server: u64, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
pub unsafe fn GetProcessOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetProcessOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), dumpfile.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn ConnectSession(&self, flags: u32, historylimit: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(historylimit)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServer<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServers<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn TerminateProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachProcesses(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EndSession(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetExitCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn DispatchCallbacks(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn ExitDispatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), client.into_param().abi()).ok()
}
pub unsafe fn CreateClient(&self) -> ::windows::core::Result<IDebugClient> {
let mut result__: <IDebugClient as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugClient>(result__)
}
pub unsafe fn GetInputCallbacks(&self) -> ::windows::core::Result<IDebugInputCallbacks> {
let mut result__: <IDebugInputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugInputCallbacks>(result__)
}
pub unsafe fn SetInputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugInputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputCallbacks(&self) -> ::windows::core::Result<IDebugOutputCallbacks> {
let mut result__: <IDebugOutputCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacks>(result__)
}
pub unsafe fn SetOutputCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn GetOutputMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), client.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOtherOutputMask<'a, Param0: ::windows::core::IntoParam<'a, IDebugClient>>(&self, client: Param0, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), client.into_param().abi(), ::core::mem::transmute(mask)).ok()
}
pub unsafe fn GetOutputWidth(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetOutputWidth(&self, columns: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(columns)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefix(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentity(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentity<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacks(&self) -> ::windows::core::Result<IDebugEventCallbacks> {
let mut result__: <IDebugEventCallbacks as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacks>(result__)
}
pub unsafe fn SetEventCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn FlushCallbacks(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, dumpfile: Param0, qualifier: u32, formatflags: u32, comment: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), dumpfile.into_param().abi(), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, infofile: Param0, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), infofile.into_param().abi(), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn EndProcessServer(&self, server: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(server)).ok()
}
pub unsafe fn WaitForProcessServerEnd(&self, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), ::core::mem::transmute(timeout)).ok()
}
pub unsafe fn IsKernelDebuggerEnabled(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn TerminateCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DetachCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn AbandonCurrentProcess(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessSystemIdByExecutableNameWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, exename: Param1, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), exename.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRunningProcessDescriptionWide(&self, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
::core::mem::transmute(systemid),
::core::mem::transmute(flags),
::core::mem::transmute(exename),
::core::mem::transmute(exenamesize),
::core::mem::transmute(actualexenamesize),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(actualdescriptionsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttachWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(createflags), ::core::mem::transmute(processid), ::core::mem::transmute(attachflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteDumpFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, qualifier: u32, formatflags: u32, comment: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(qualifier), ::core::mem::transmute(formatflags), comment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDumpInformationFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberDumpFiles(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFile(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDumpFileWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(handle), ::core::mem::transmute(r#type)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AttachKernelWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, connectoptions: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), connectoptions.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKernelConnectionOptionsWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(optionssize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKernelConnectionOptionsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartProcessServerWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, flags: u32, options: Param1, reserved: *const ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), options.into_param().abi(), ::core::mem::transmute(reserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ConnectProcessServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, remoteoptions: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), remoteoptions.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartServerWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, options: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), options.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputServersWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, machine: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), machine.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetOutputCallbacksWide(&self) -> ::windows::core::Result<IDebugOutputCallbacksWide> {
let mut result__: <IDebugOutputCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugOutputCallbacksWide>(result__)
}
pub unsafe fn SetOutputCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugOutputCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOutputLinePrefixWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(prefixsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, prefix: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), prefix.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIdentityWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(identitysize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputIdentityWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, flags: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), format.into_param().abi()).ok()
}
pub unsafe fn GetEventCallbacksWide(&self) -> ::windows::core::Result<IDebugEventCallbacksWide> {
let mut result__: <IDebugEventCallbacksWide as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugEventCallbacksWide>(result__)
}
pub unsafe fn SetEventCallbacksWide<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventCallbacksWide>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcess2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, commandline: Param1, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: Param4, environment: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), commandline.into_param().abi(), ::core::mem::transmute(optionsbuffer), ::core::mem::transmute(optionsbuffersize), initialdirectory.into_param().abi(), environment.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessAndAttach2Wide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
server: u64,
commandline: Param1,
optionsbuffer: *const ::core::ffi::c_void,
optionsbuffersize: u32,
initialdirectory: Param4,
environment: Param5,
processid: u32,
attachflags: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(
::core::mem::transmute_copy(self),
::core::mem::transmute(server),
commandline.into_param().abi(),
::core::mem::transmute(optionsbuffer),
::core::mem::transmute(optionsbuffersize),
initialdirectory.into_param().abi(),
environment.into_param().abi(),
::core::mem::transmute(processid),
::core::mem::transmute(attachflags),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefix<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PushOutputLinePrefixWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, newprefix: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), newprefix.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn PopOutputLinePrefix(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
pub unsafe fn GetNumberInputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOutputCallbacks(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberEventCallbacks(&self, eventflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockString(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetQuitLockStringWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetQuitLockStringWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, string: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), string.into_param().abi()).ok()
}
pub unsafe fn SetEventContextCallbacks<'a, Param0: ::windows::core::IntoParam<'a, IDebugEventContextCallbacks>>(&self, callbacks: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), callbacks.into_param().abi()).ok()
}
pub unsafe fn SetClientContext(&self, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenDumpFileWide2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, filename: Param0, filehandle: u64, alternatearch: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filehandle), ::core::mem::transmute(alternatearch)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugClient8 {
type Vtable = IDebugClient8_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcec43add_6375_469e_83d5_414e4033c19a);
}
impl ::core::convert::From<IDebugClient8> for ::windows::core::IUnknown {
fn from(value: IDebugClient8) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugClient8> for ::windows::core::IUnknown {
fn from(value: &IDebugClient8) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugClient8 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugClient8 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugClient8_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, ids: *mut u32, count: u32, actualcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, historylimit: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, client: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, columns: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dumpfile: super::super::super::Foundation::PSTR, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, infofile: super::super::super::Foundation::PSTR, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, exename: super::super::super::Foundation::PWSTR, flags: u32, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, systemid: u32, flags: u32, exename: super::super::super::Foundation::PWSTR, exenamesize: u32, actualexenamesize: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, actualdescriptionsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, createflags: u32, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, qualifier: u32, formatflags: u32, comment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, r#type: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32, handle: *mut u64, r#type: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, connectoptions: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, optionssize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, options: super::super::super::Foundation::PWSTR, reserved: *const ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, remoteoptions: super::super::super::Foundation::PWSTR, server: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, machine: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, prefixsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prefix: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, identitysize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PSTR, environment: super::super::super::Foundation::PSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, commandline: super::super::super::Foundation::PWSTR, optionsbuffer: *const ::core::ffi::c_void, optionsbuffersize: u32, initialdirectory: super::super::super::Foundation::PWSTR, environment: super::super::super::Foundation::PWSTR, processid: u32, attachflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newprefix: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventflags: u32, count: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, string: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, callbacks: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: super::super::super::Foundation::PWSTR, filehandle: u64, alternatearch: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugCodeContext(pub ::windows::core::IUnknown);
impl IDebugCodeContext {
pub unsafe fn GetDocumentContext(&self) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn SetBreakPoint(&self, bps: BREAKPOINT_STATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(bps)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugCodeContext {
type Vtable = IDebugCodeContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c13_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugCodeContext> for ::windows::core::IUnknown {
fn from(value: IDebugCodeContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugCodeContext> for ::windows::core::IUnknown {
fn from(value: &IDebugCodeContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugCodeContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugCodeContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugCodeContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bps: BREAKPOINT_STATE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl(pub ::windows::core::IUnknown);
impl IDebugControl {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
}
unsafe impl ::windows::core::Interface for IDebugControl {
type Vtable = IDebugControl_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5182e668_105e_416e_ad92_24ef800424ba);
}
impl ::core::convert::From<IDebugControl> for ::windows::core::IUnknown {
fn from(value: IDebugControl) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl> for ::windows::core::IUnknown {
fn from(value: &IDebugControl) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl2(pub ::windows::core::IUnknown);
impl IDebugControl2 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugControl2 {
type Vtable = IDebugControl2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd4366723_44df_4bed_8c7e_4c05424f4588);
}
impl ::core::convert::From<IDebugControl2> for ::windows::core::IUnknown {
fn from(value: IDebugControl2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl2> for ::windows::core::IUnknown {
fn from(value: &IDebugControl2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl3(pub ::windows::core::IUnknown);
impl IDebugControl3 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetAssemblyOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetExpressionSyntax(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExpressionSyntax(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
pub unsafe fn GetNumberExpressionSyntaxes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNames(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetNumberEvents(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescription<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentEventIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetNextEventIndex(&self, relation: u32, value: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(relation), ::core::mem::transmute(value), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugControl3 {
type Vtable = IDebugControl3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7df74a86_b03f_407f_90ab_a20dadcead08);
}
impl ::core::convert::From<IDebugControl3> for ::windows::core::IUnknown {
fn from(value: IDebugControl3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl3> for ::windows::core::IUnknown {
fn from(value: &IDebugControl3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, events: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, relation: u32, value: u32, nextindex: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl4(pub ::windows::core::IUnknown);
impl IDebugControl4 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetAssemblyOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetExpressionSyntax(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExpressionSyntax(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
pub unsafe fn GetNumberExpressionSyntaxes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNames(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetNumberEvents(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescription<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentEventIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetNextEventIndex(&self, relation: u32, value: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(relation), ::core::mem::transmute(value), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFileWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InputWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInputWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaListWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptTextWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AssembleWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisassembleWide(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNamesWide(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacroWide(&self, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacroWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).133)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).134)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetBreakpointByIndex2(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).135)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn GetBreakpointById2(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).136)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn AddBreakpoint2(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).137)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn RemoveBreakpoint2<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).138)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtensionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).139)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).140)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtensionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).141)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunctionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).142)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterTextWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).143)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).144)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).145)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgumentWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).146)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgumentWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).147)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).148)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).149)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformationWide(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).150)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).151)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).152)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).153)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNamesWide(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).154)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescriptionWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).155)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).156)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).157)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2Wide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).158)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).159)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetSystemVersionValues(&self, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).160)(::core::mem::transmute_copy(self), ::core::mem::transmute(platformid), ::core::mem::transmute(win32major), ::core::mem::transmute(win32minor), ::core::mem::transmute(kdmajor), ::core::mem::transmute(kdminor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionString(&self, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).161)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionStringWide(&self, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).162)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTrace(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).163)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).164)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetStoredEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).165)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
::core::mem::transmute(contextused),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatus(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).166)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatusWide(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).167)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
pub unsafe fn ResetManagedStatus(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).168)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugControl4 {
type Vtable = IDebugControl4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x94e60ce9_9b41_4b19_9fc0_6d9eb35272b3);
}
impl ::core::convert::From<IDebugControl4> for ::windows::core::IUnknown {
fn from(value: IDebugControl4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl4> for ::windows::core::IUnknown {
fn from(value: &IDebugControl4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, events: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, relation: u32, value: u32, nextindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PWSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PWSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, dsttext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl5(pub ::windows::core::IUnknown);
impl IDebugControl5 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetAssemblyOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetExpressionSyntax(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExpressionSyntax(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
pub unsafe fn GetNumberExpressionSyntaxes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNames(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetNumberEvents(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescription<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentEventIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetNextEventIndex(&self, relation: u32, value: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(relation), ::core::mem::transmute(value), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFileWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InputWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInputWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaListWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptTextWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AssembleWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisassembleWide(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNamesWide(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacroWide(&self, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacroWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).133)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).134)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetBreakpointByIndex2(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).135)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn GetBreakpointById2(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).136)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn AddBreakpoint2(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).137)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn RemoveBreakpoint2<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).138)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtensionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).139)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).140)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtensionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).141)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunctionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).142)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterTextWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).143)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).144)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).145)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgumentWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).146)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgumentWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).147)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).148)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).149)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformationWide(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).150)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).151)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).152)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).153)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNamesWide(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).154)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescriptionWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).155)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).156)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).157)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2Wide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).158)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).159)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetSystemVersionValues(&self, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).160)(::core::mem::transmute_copy(self), ::core::mem::transmute(platformid), ::core::mem::transmute(win32major), ::core::mem::transmute(win32minor), ::core::mem::transmute(kdmajor), ::core::mem::transmute(kdminor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionString(&self, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).161)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionStringWide(&self, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).162)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTrace(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).163)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).164)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetStoredEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).165)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
::core::mem::transmute(contextused),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatus(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).166)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatusWide(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).167)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
pub unsafe fn ResetManagedStatus(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).168)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTraceEx(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).169)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).170)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTraceEx(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).171)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).172)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetBreakpointByGuid(&self, guid: *const ::windows::core::GUID) -> ::windows::core::Result<IDebugBreakpoint3> {
let mut result__: <IDebugBreakpoint3 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).173)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), &mut result__).from_abi::<IDebugBreakpoint3>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugControl5 {
type Vtable = IDebugControl5_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb2ffe162_2412_429f_8d1d_5bf6dd824696);
}
impl ::core::convert::From<IDebugControl5> for ::windows::core::IUnknown {
fn from(value: IDebugControl5) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl5> for ::windows::core::IUnknown {
fn from(value: &IDebugControl5) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl5_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, events: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, relation: u32, value: u32, nextindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PWSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PWSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, dsttext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl6(pub ::windows::core::IUnknown);
impl IDebugControl6 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetAssemblyOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetExpressionSyntax(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExpressionSyntax(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
pub unsafe fn GetNumberExpressionSyntaxes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNames(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetNumberEvents(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescription<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentEventIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetNextEventIndex(&self, relation: u32, value: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(relation), ::core::mem::transmute(value), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFileWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InputWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInputWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaListWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptTextWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AssembleWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisassembleWide(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNamesWide(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacroWide(&self, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacroWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).133)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).134)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetBreakpointByIndex2(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).135)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn GetBreakpointById2(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).136)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn AddBreakpoint2(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).137)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn RemoveBreakpoint2<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).138)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtensionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).139)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).140)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtensionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).141)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunctionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).142)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterTextWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).143)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).144)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).145)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgumentWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).146)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgumentWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).147)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).148)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).149)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformationWide(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).150)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).151)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).152)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).153)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNamesWide(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).154)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescriptionWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).155)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).156)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).157)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2Wide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).158)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).159)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetSystemVersionValues(&self, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).160)(::core::mem::transmute_copy(self), ::core::mem::transmute(platformid), ::core::mem::transmute(win32major), ::core::mem::transmute(win32minor), ::core::mem::transmute(kdmajor), ::core::mem::transmute(kdminor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionString(&self, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).161)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionStringWide(&self, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).162)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTrace(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).163)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).164)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetStoredEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).165)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
::core::mem::transmute(contextused),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatus(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).166)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatusWide(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).167)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
pub unsafe fn ResetManagedStatus(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).168)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTraceEx(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).169)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).170)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTraceEx(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).171)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).172)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetBreakpointByGuid(&self, guid: *const ::windows::core::GUID) -> ::windows::core::Result<IDebugBreakpoint3> {
let mut result__: <IDebugBreakpoint3 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).173)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), &mut result__).from_abi::<IDebugBreakpoint3>(result__)
}
pub unsafe fn GetExecutionStatusEx(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).174)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSynchronizationStatus(&self, sendsattempted: *mut u32, secondssincelastresponse: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).175)(::core::mem::transmute_copy(self), ::core::mem::transmute(sendsattempted), ::core::mem::transmute(secondssincelastresponse)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugControl6 {
type Vtable = IDebugControl6_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbc0d583f_126d_43a1_9cc4_a860ab1d537b);
}
impl ::core::convert::From<IDebugControl6> for ::windows::core::IUnknown {
fn from(value: IDebugControl6) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl6> for ::windows::core::IUnknown {
fn from(value: &IDebugControl6) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl6 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl6 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl6_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, events: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, relation: u32, value: u32, nextindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PWSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PWSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, dsttext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sendsattempted: *mut u32, secondssincelastresponse: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugControl7(pub ::windows::core::IUnknown);
impl IDebugControl7 {
pub unsafe fn GetInterrupt(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetInterrupt(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInterruptTimeout(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetInterruptTimeout(&self, seconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(seconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
pub unsafe fn CloseLogFile(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetLogMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetLogMask(&self, mask: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Input(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutput<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaList<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPrompt<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaList<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptText(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
pub unsafe fn OutputCurrentState(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn OutputVersionInformation(&self, outputcontrol: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol)).ok()
}
pub unsafe fn GetNotifyEventHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetNotifyEventHandle(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Assemble<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Disassemble(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
pub unsafe fn GetDisassembleEffectiveOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassembly(&self, outputcontrol: u32, offset: u64, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn OutputDisassemblyLines(&self, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(previouslines),
::core::mem::transmute(totallines),
::core::mem::transmute(offset),
::core::mem::transmute(flags),
::core::mem::transmute(offsetline),
::core::mem::transmute(startoffset),
::core::mem::transmute(endoffset),
::core::mem::transmute(lineoffsets),
)
.ok()
}
pub unsafe fn GetNearInstruction(&self, offset: u64, delta: i32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTrace(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
pub unsafe fn GetReturnOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetDebuggeeType(&self, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
pub unsafe fn GetActualProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetExecutingProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPossibleExecutingProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetPossibleExecutingProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
pub unsafe fn GetNumberProcessors(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersion(&self, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(
::core::mem::transmute_copy(self),
::core::mem::transmute(platformid),
::core::mem::transmute(major),
::core::mem::transmute(minor),
::core::mem::transmute(servicepackstring),
::core::mem::transmute(servicepackstringsize),
::core::mem::transmute(servicepackstringused),
::core::mem::transmute(servicepacknumber),
::core::mem::transmute(buildstring),
::core::mem::transmute(buildstringsize),
::core::mem::transmute(buildstringused),
)
.ok()
}
pub unsafe fn GetPageSize(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsPointer64Bit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadBugCheckData(&self, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(code), ::core::mem::transmute(arg1), ::core::mem::transmute(arg2), ::core::mem::transmute(arg3), ::core::mem::transmute(arg4)).ok()
}
pub unsafe fn GetNumberSupportedProcessorTypes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSupportedProcessorTypes(&self, start: u32, count: u32, types: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(types)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNames(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetEffectiveProcessorType(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetEffectiveProcessorType(&self, r#type: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetExecutionStatus(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExecutionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn GetCodeLevel(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCodeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetEngineOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetEngineOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetSystemErrorControl(&self, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
pub unsafe fn SetSystemErrorControl(&self, outputlevel: u32, breaklevel: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputlevel), ::core::mem::transmute(breaklevel)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacro(&self, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacro<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
pub unsafe fn GetRadix(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetRadix(&self, radix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(radix)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValue(&self, r#in: *const DEBUG_VALUE, outtype: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#in), ::core::mem::transmute(outtype), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CoerceValues(&self, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(r#in), ::core::mem::transmute(outtypes), ::core::mem::transmute(out)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Execute<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetNumberBreakpoints(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetBreakpointByIndex(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointById(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn GetBreakpointParameters(&self, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn AddBreakpoint(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint> {
let mut result__: <IDebugBreakpoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint>(result__)
}
pub unsafe fn RemoveBreakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtension<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn RemoveExtension(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtension<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis32(&self, api: *mut WINDBG_EXTENSION_APIS32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub unsafe fn GetWindbgExtensionApis64(&self, api: *mut WINDBG_EXTENSION_APIS64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), ::core::mem::transmute(api)).ok()
}
pub unsafe fn GetNumberEventFilters(&self, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), ::core::mem::transmute(specificevents), ::core::mem::transmute(specificexceptions), ::core::mem::transmute(arbitraryexceptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn GetSpecificFilterParameters(&self, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetSpecificFilterParameters(&self, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgument(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgument<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
pub unsafe fn GetExceptionFilterParameters(&self, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(codes), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
pub unsafe fn SetExceptionFilterParameters(&self, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommand(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommand<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
pub unsafe fn WaitForEvent(&self, flags: u32, timeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(timeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
pub unsafe fn GetCurrentTimeDate(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetDumpFormatFlags(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberTextReplacements(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).99)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
pub unsafe fn RemoveTextReplacements(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputTextReplacements(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetAssemblyOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetAssemblyOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn GetExpressionSyntax(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetExpressionSyntax(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
pub unsafe fn GetNumberExpressionSyntaxes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNames(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
pub unsafe fn GetNumberEvents(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescription<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentEventIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetNextEventIndex(&self, relation: u32, value: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(relation), ::core::mem::transmute(value), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFileWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(append)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFileWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, file: Param0, append: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), file.into_param().abi(), append.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InputWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(inputsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReturnInputWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, buffer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), buffer.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ControlledOutputVaListWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, mask: u32, format: Param2, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(mask), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputPromptVaListWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, format: Param1, args: *const i8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), format.into_param().abi(), ::core::mem::transmute(args)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPromptTextWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AssembleWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, instr: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), instr.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisassembleWide(&self, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(disassemblysize), ::core::mem::transmute(endoffset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProcessorTypeNamesWide(&self, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextMacroWide(&self, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(macrosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextMacroWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, slot: u32, r#macro: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(slot), r#macro.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, expression: Param0, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), expression.into_param().abi(), ::core::mem::transmute(desiredtype), ::core::mem::transmute(value), ::core::mem::transmute(remainderindex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, command: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).133)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), command.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExecuteCommandFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, outputcontrol: u32, commandfile: Param1, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).134)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), commandfile.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetBreakpointByIndex2(&self, index: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).135)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn GetBreakpointById2(&self, id: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).136)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn AddBreakpoint2(&self, r#type: u32, desiredid: u32) -> ::windows::core::Result<IDebugBreakpoint2> {
let mut result__: <IDebugBreakpoint2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).137)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), ::core::mem::transmute(desiredid), &mut result__).from_abi::<IDebugBreakpoint2>(result__)
}
pub unsafe fn RemoveBreakpoint2<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).138)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddExtensionWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0, flags: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).139)(::core::mem::transmute_copy(self), path.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionByPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).140)(::core::mem::transmute_copy(self), path.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CallExtensionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, function: Param1, arguments: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).141)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), function.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExtensionFunctionWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, handle: u64, funcname: Param1, function: *mut ::core::option::Option<super::super::super::Foundation::FARPROC>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).142)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), funcname.into_param().abi(), ::core::mem::transmute(function)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterTextWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).143)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(textsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventFilterCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).144)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventFilterCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).145)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSpecificFilterArgumentWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).146)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(argumentsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSpecificFilterArgumentWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, argument: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).147)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), argument.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExceptionFilterSecondCommandWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).148)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(commandsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExceptionFilterSecondCommandWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, command: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).149)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), command.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLastEventInformationWide(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).150)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
::core::mem::transmute(description),
::core::mem::transmute(descriptionsize),
::core::mem::transmute(descriptionused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).151)(
::core::mem::transmute_copy(self),
srctext.into_param().abi(),
::core::mem::transmute(index),
::core::mem::transmute(srcbuffer),
::core::mem::transmute(srcbuffersize),
::core::mem::transmute(srcsize),
::core::mem::transmute(dstbuffer),
::core::mem::transmute(dstbuffersize),
::core::mem::transmute(dstsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextReplacementWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, srctext: Param0, dsttext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).152)(::core::mem::transmute_copy(self), srctext.into_param().abi(), dsttext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetExpressionSyntaxByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, abbrevname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).153)(::core::mem::transmute_copy(self), abbrevname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetExpressionSyntaxNamesWide(&self, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).154)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(fullnamebuffer),
::core::mem::transmute(fullnamebuffersize),
::core::mem::transmute(fullnamesize),
::core::mem::transmute(abbrevnamebuffer),
::core::mem::transmute(abbrevnamebuffersize),
::core::mem::transmute(abbrevnamesize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventIndexDescriptionWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, which: u32, buffer: Param2, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).155)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(which), buffer.into_param().abi(), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).156)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).157)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLogFile2Wide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).158)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenLogFile2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).159)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetSystemVersionValues(&self, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).160)(::core::mem::transmute_copy(self), ::core::mem::transmute(platformid), ::core::mem::transmute(win32major), ::core::mem::transmute(win32minor), ::core::mem::transmute(kdmajor), ::core::mem::transmute(kdminor)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionString(&self, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).161)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSystemVersionStringWide(&self, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).162)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTrace(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).163)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTrace(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).164)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetStoredEventInformation(&self, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).165)(
::core::mem::transmute_copy(self),
::core::mem::transmute(r#type),
::core::mem::transmute(processid),
::core::mem::transmute(threadid),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
::core::mem::transmute(contextused),
::core::mem::transmute(extrainformation),
::core::mem::transmute(extrainformationsize),
::core::mem::transmute(extrainformationused),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatus(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).166)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetManagedStatusWide(&self, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).167)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(whichstring), ::core::mem::transmute(string), ::core::mem::transmute(stringsize), ::core::mem::transmute(stringneeded)).ok()
}
pub unsafe fn ResetManagedStatus(&self, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).168)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStackTraceEx(&self, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).169)(::core::mem::transmute_copy(self), ::core::mem::transmute(frameoffset), ::core::mem::transmute(stackoffset), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(framesfilled)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).170)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(frames), ::core::mem::transmute(framessize), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextStackTraceEx(&self, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).171)(
::core::mem::transmute_copy(self),
::core::mem::transmute(startcontext),
::core::mem::transmute(startcontextsize),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(framesfilled),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputContextStackTraceEx(&self, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).172)(
::core::mem::transmute_copy(self),
::core::mem::transmute(outputcontrol),
::core::mem::transmute(frames),
::core::mem::transmute(framessize),
::core::mem::transmute(framecontexts),
::core::mem::transmute(framecontextssize),
::core::mem::transmute(framecontextsentrysize),
::core::mem::transmute(flags),
)
.ok()
}
pub unsafe fn GetBreakpointByGuid(&self, guid: *const ::windows::core::GUID) -> ::windows::core::Result<IDebugBreakpoint3> {
let mut result__: <IDebugBreakpoint3 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).173)(::core::mem::transmute_copy(self), ::core::mem::transmute(guid), &mut result__).from_abi::<IDebugBreakpoint3>(result__)
}
pub unsafe fn GetExecutionStatusEx(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).174)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSynchronizationStatus(&self, sendsattempted: *mut u32, secondssincelastresponse: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).175)(::core::mem::transmute_copy(self), ::core::mem::transmute(sendsattempted), ::core::mem::transmute(secondssincelastresponse)).ok()
}
pub unsafe fn GetDebuggeeType2(&self, flags: u32, class: *mut u32, qualifier: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).176)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(class), ::core::mem::transmute(qualifier)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugControl7 {
type Vtable = IDebugControl7_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb86fb3b1_80d4_475b_aea3_cf06539cf63a);
}
impl ::core::convert::From<IDebugControl7> for ::windows::core::IUnknown {
fn from(value: IDebugControl7) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugControl7> for ::windows::core::IUnknown {
fn from(value: &IDebugControl7) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugControl7 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugControl7 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugControl7_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, seconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, flags: u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, previouslines: u32, totallines: u32, offset: u64, flags: u32, offsetline: *mut u32, startoffset: *mut u64, endoffset: *mut u64, lineoffsets: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, nearoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, major: *mut u32, minor: *mut u32, servicepackstring: super::super::super::Foundation::PSTR, servicepackstringsize: u32, servicepackstringused: *mut u32, servicepacknumber: *mut u32, buildstring: super::super::super::Foundation::PSTR, buildstringsize: u32, buildstringused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, code: *mut u32, arg1: *mut u64, arg2: *mut u64, arg3: *mut u64, arg4: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, types: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: *mut u32, breaklevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputlevel: u32, breaklevel: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, radix: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#in: *const DEBUG_VALUE, outtype: u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, r#in: *const DEBUG_VALUE, outtypes: *const u32, out: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ids: *const u32, start: u32, params: *mut DEBUG_BREAKPOINT_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PSTR, arguments: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, api: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, specificevents: *mut u32, specificexceptions: *mut u32, arbitraryexceptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *const DEBUG_SPECIFIC_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, codes: *const u32, start: u32, params: *mut DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, params: *const DEBUG_EXCEPTION_FILTER_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, timeout: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, timedate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formatflags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numrepl: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, index: u32, srcbuffer: super::super::super::Foundation::PSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PSTR, dsttext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, events: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, relation: u32, value: u32, nextindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, append: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, append: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, inputsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, mask: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, format: super::super::super::Foundation::PWSTR, args: *const i8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, instr: super::super::super::Foundation::PWSTR, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, disassemblysize: *mut u32, endoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, macrosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, slot: u32, r#macro: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, desiredtype: u32, value: *mut DEBUG_VALUE, remainderindex: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, command: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, commandfile: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: u32, desiredid: u32, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, flags: u32, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, function: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, funcname: super::super::super::Foundation::PWSTR, function: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, textsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, argumentsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, argument: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, commandsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, command: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32, description: super::super::super::Foundation::PWSTR, descriptionsize: u32, descriptionused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, index: u32, srcbuffer: super::super::super::Foundation::PWSTR, srcbuffersize: u32, srcsize: *mut u32, dstbuffer: super::super::super::Foundation::PWSTR, dstbuffersize: u32, dstsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, srctext: super::super::super::Foundation::PWSTR, dsttext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abbrevname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, fullnamebuffer: super::super::super::Foundation::PWSTR, fullnamebuffersize: u32, fullnamesize: *mut u32, abbrevnamebuffer: super::super::super::Foundation::PWSTR, abbrevnamebuffersize: u32, abbrevnamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, descsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, filesize: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, platformid: *mut u32, win32major: *mut u32, win32minor: *mut u32, kdmajor: *mut u32, kdminor: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut u32, processid: *mut u32, threadid: *mut u32, context: *mut ::core::ffi::c_void, contextsize: u32, contextused: *mut u32, extrainformation: *mut ::core::ffi::c_void, extrainformationsize: u32, extrainformationused: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: *mut u32, whichstring: u32, string: super::super::super::Foundation::PWSTR, stringsize: u32, stringneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, frameoffset: u64, stackoffset: u64, instructionoffset: u64, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startcontext: *const ::core::ffi::c_void, startcontextsize: u32, frames: *mut DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *mut ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, framesfilled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, frames: *const DEBUG_STACK_FRAME_EX, framessize: u32, framecontexts: *const ::core::ffi::c_void, framecontextssize: u32, framecontextsentrysize: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *const ::windows::core::GUID, bp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sendsattempted: *mut u32, secondssincelastresponse: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, class: *mut u32, qualifier: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugCookie(pub ::windows::core::IUnknown);
impl IDebugCookie {
pub unsafe fn SetDebugCookie(&self, dwdebugappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwdebugappcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugCookie {
type Vtable = IDebugCookie_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c39_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugCookie> for ::windows::core::IUnknown {
fn from(value: IDebugCookie) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugCookie> for ::windows::core::IUnknown {
fn from(value: &IDebugCookie) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugCookie {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugCookie {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugCookie_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwdebugappcookie: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDataSpaces(pub ::windows::core::IUnknown);
impl IDebugDataSpaces {
pub unsafe fn ReadVirtual(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtual(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SearchVirtual(&self, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(length), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), ::core::mem::transmute(patterngranularity), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadVirtualUncached(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtualUncached(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadPointersVirtual(&self, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn WritePointersVirtual(&self, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn ReadPhysical(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WritePhysical(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadControl(&self, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteControl(&self, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadMsr(&self, msr: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn WriteMsr(&self, msr: u32, value: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), ::core::mem::transmute(value)).ok()
}
pub unsafe fn ReadBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CheckLowMemory(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadDebuggerData(&self, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn ReadProcessorSystemData(&self, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDataSpaces {
type Vtable = IDebugDataSpaces_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x88f7dfab_3ea7_4c3a_aefb_c4e8106173aa);
}
impl ::core::convert::From<IDebugDataSpaces> for ::windows::core::IUnknown {
fn from(value: IDebugDataSpaces) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDataSpaces> for ::windows::core::IUnknown {
fn from(value: &IDebugDataSpaces) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDataSpaces {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDataSpaces {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDataSpaces_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32, matchoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDataSpaces2(pub ::windows::core::IUnknown);
impl IDebugDataSpaces2 {
pub unsafe fn ReadVirtual(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtual(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SearchVirtual(&self, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(length), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), ::core::mem::transmute(patterngranularity), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadVirtualUncached(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtualUncached(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadPointersVirtual(&self, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn WritePointersVirtual(&self, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn ReadPhysical(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WritePhysical(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadControl(&self, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteControl(&self, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadMsr(&self, msr: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn WriteMsr(&self, msr: u32, value: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), ::core::mem::transmute(value)).ok()
}
pub unsafe fn ReadBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CheckLowMemory(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadDebuggerData(&self, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn ReadProcessorSystemData(&self, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn VirtualToPhysical(&self, r#virtual: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetVirtualTranslationPhysicalOffsets(&self, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), ::core::mem::transmute(offsets), ::core::mem::transmute(offsetssize), ::core::mem::transmute(levels)).ok()
}
pub unsafe fn ReadHandleData(&self, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(datatype), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn FillVirtual(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn FillPhysical(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Memory")]
pub unsafe fn QueryVirtual(&self, offset: u64) -> ::windows::core::Result<super::super::Memory::MEMORY_BASIC_INFORMATION64> {
let mut result__: <super::super::Memory::MEMORY_BASIC_INFORMATION64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<super::super::Memory::MEMORY_BASIC_INFORMATION64>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDataSpaces2 {
type Vtable = IDebugDataSpaces2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a5e852f_96e9_468f_ac1b_0b3addc4a049);
}
impl ::core::convert::From<IDebugDataSpaces2> for ::windows::core::IUnknown {
fn from(value: IDebugDataSpaces2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDataSpaces2> for ::windows::core::IUnknown {
fn from(value: &IDebugDataSpaces2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDataSpaces2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDataSpaces2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDataSpaces2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32, matchoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, physical: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Memory")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, info: *mut super::super::Memory::MEMORY_BASIC_INFORMATION64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Memory"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDataSpaces3(pub ::windows::core::IUnknown);
impl IDebugDataSpaces3 {
pub unsafe fn ReadVirtual(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtual(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SearchVirtual(&self, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(length), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), ::core::mem::transmute(patterngranularity), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadVirtualUncached(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtualUncached(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadPointersVirtual(&self, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn WritePointersVirtual(&self, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn ReadPhysical(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WritePhysical(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadControl(&self, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteControl(&self, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadMsr(&self, msr: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn WriteMsr(&self, msr: u32, value: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), ::core::mem::transmute(value)).ok()
}
pub unsafe fn ReadBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CheckLowMemory(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadDebuggerData(&self, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn ReadProcessorSystemData(&self, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn VirtualToPhysical(&self, r#virtual: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetVirtualTranslationPhysicalOffsets(&self, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), ::core::mem::transmute(offsets), ::core::mem::transmute(offsetssize), ::core::mem::transmute(levels)).ok()
}
pub unsafe fn ReadHandleData(&self, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(datatype), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn FillVirtual(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn FillPhysical(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Memory")]
pub unsafe fn QueryVirtual(&self, offset: u64) -> ::windows::core::Result<super::super::Memory::MEMORY_BASIC_INFORMATION64> {
let mut result__: <super::super::Memory::MEMORY_BASIC_INFORMATION64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<super::super::Memory::MEMORY_BASIC_INFORMATION64>(result__)
}
pub unsafe fn ReadImageNtHeaders(&self, imagebase: u64) -> ::windows::core::Result<IMAGE_NT_HEADERS64> {
let mut result__: <IMAGE_NT_HEADERS64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagebase), &mut result__).from_abi::<IMAGE_NT_HEADERS64>(result__)
}
pub unsafe fn ReadTagged(&self, tag: *const ::windows::core::GUID, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, totalsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(tag), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(totalsize)).ok()
}
pub unsafe fn StartEnumTagged(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNextTagged(&self, handle: u64, tag: *mut ::windows::core::GUID, size: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(tag), ::core::mem::transmute(size)).ok()
}
pub unsafe fn EndEnumTagged(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDataSpaces3 {
type Vtable = IDebugDataSpaces3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x23f79d6c_8aaf_4f7c_a607_9995f5407e63);
}
impl ::core::convert::From<IDebugDataSpaces3> for ::windows::core::IUnknown {
fn from(value: IDebugDataSpaces3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDataSpaces3> for ::windows::core::IUnknown {
fn from(value: &IDebugDataSpaces3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDataSpaces3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDataSpaces3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDataSpaces3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32, matchoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, physical: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Memory")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, info: *mut super::super::Memory::MEMORY_BASIC_INFORMATION64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Memory"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebase: u64, headers: *mut IMAGE_NT_HEADERS64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tag: *const ::windows::core::GUID, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, totalsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, tag: *mut ::windows::core::GUID, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDataSpaces4(pub ::windows::core::IUnknown);
impl IDebugDataSpaces4 {
pub unsafe fn ReadVirtual(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtual(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SearchVirtual(&self, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(length), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), ::core::mem::transmute(patterngranularity), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadVirtualUncached(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteVirtualUncached(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadPointersVirtual(&self, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn WritePointersVirtual(&self, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(offset), ::core::mem::transmute(ptrs)).ok()
}
pub unsafe fn ReadPhysical(&self, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WritePhysical(&self, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadControl(&self, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteControl(&self, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteIo(&self, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(interfacetype), ::core::mem::transmute(busnumber), ::core::mem::transmute(addressspace), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn ReadMsr(&self, msr: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn WriteMsr(&self, msr: u32, value: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(msr), ::core::mem::transmute(value)).ok()
}
pub unsafe fn ReadBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBusData(&self, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(busdatatype), ::core::mem::transmute(busnumber), ::core::mem::transmute(slotnumber), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn CheckLowMemory(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ReadDebuggerData(&self, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn ReadProcessorSystemData(&self, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn VirtualToPhysical(&self, r#virtual: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetVirtualTranslationPhysicalOffsets(&self, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#virtual), ::core::mem::transmute(offsets), ::core::mem::transmute(offsetssize), ::core::mem::transmute(levels)).ok()
}
pub unsafe fn ReadHandleData(&self, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(datatype), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(datasize)).ok()
}
pub unsafe fn FillVirtual(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn FillPhysical(&self, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(size), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Memory")]
pub unsafe fn QueryVirtual(&self, offset: u64) -> ::windows::core::Result<super::super::Memory::MEMORY_BASIC_INFORMATION64> {
let mut result__: <super::super::Memory::MEMORY_BASIC_INFORMATION64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<super::super::Memory::MEMORY_BASIC_INFORMATION64>(result__)
}
pub unsafe fn ReadImageNtHeaders(&self, imagebase: u64) -> ::windows::core::Result<IMAGE_NT_HEADERS64> {
let mut result__: <IMAGE_NT_HEADERS64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagebase), &mut result__).from_abi::<IMAGE_NT_HEADERS64>(result__)
}
pub unsafe fn ReadTagged(&self, tag: *const ::windows::core::GUID, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, totalsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(tag), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(totalsize)).ok()
}
pub unsafe fn StartEnumTagged(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNextTagged(&self, handle: u64, tag: *mut ::windows::core::GUID, size: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(tag), ::core::mem::transmute(size)).ok()
}
pub unsafe fn EndEnumTagged(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
pub unsafe fn GetOffsetInformation(&self, space: u32, which: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(space), ::core::mem::transmute(which), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(infosize)).ok()
}
pub unsafe fn GetNextDifferentlyValidOffsetVirtual(&self, offset: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetValidRegionVirtual(&self, base: u64, size: u32, validbase: *mut u64, validsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), ::core::mem::transmute(validbase), ::core::mem::transmute(validsize)).ok()
}
pub unsafe fn SearchVirtual2(&self, offset: u64, length: u64, flags: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(length), ::core::mem::transmute(flags), ::core::mem::transmute(pattern), ::core::mem::transmute(patternsize), ::core::mem::transmute(patterngranularity), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadMultiByteStringVirtual(&self, offset: u64, maxbytes: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(maxbytes), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringbytes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadMultiByteStringVirtualWide(&self, offset: u64, maxbytes: u32, codepage: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(maxbytes), ::core::mem::transmute(codepage), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringbytes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadUnicodeStringVirtual(&self, offset: u64, maxbytes: u32, codepage: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(maxbytes), ::core::mem::transmute(codepage), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringbytes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadUnicodeStringVirtualWide(&self, offset: u64, maxbytes: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(maxbytes), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringbytes)).ok()
}
pub unsafe fn ReadPhysical2(&self, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WritePhysical2(&self, offset: u64, flags: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDataSpaces4 {
type Vtable = IDebugDataSpaces4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd98ada1f_29e9_4ef5_a6c0_e53349883212);
}
impl ::core::convert::From<IDebugDataSpaces4> for ::windows::core::IUnknown {
fn from(value: IDebugDataSpaces4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDataSpaces4> for ::windows::core::IUnknown {
fn from(value: &IDebugDataSpaces4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDataSpaces4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDataSpaces4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDataSpaces4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, length: u64, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32, matchoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, offset: u64, ptrs: *const u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interfacetype: u32, busnumber: u32, addressspace: u32, offset: u64, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, msr: u32, value: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, busdatatype: u32, busnumber: u32, slotnumber: u32, offset: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, index: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, physical: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#virtual: u64, offsets: *mut u64, offsetssize: u32, levels: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, datatype: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, datasize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u64, size: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, filled: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Memory")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, info: *mut super::super::Memory::MEMORY_BASIC_INFORMATION64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Memory"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebase: u64, headers: *mut IMAGE_NT_HEADERS64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tag: *const ::windows::core::GUID, offset: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, totalsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, tag: *mut ::windows::core::GUID, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, space: u32, which: u32, offset: u64, buffer: *mut ::core::ffi::c_void, buffersize: u32, infosize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, nextoffset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, validbase: *mut u64, validsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, length: u64, flags: u32, pattern: *const ::core::ffi::c_void, patternsize: u32, patterngranularity: u32, matchoffset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, maxbytes: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, maxbytes: u32, codepage: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, maxbytes: u32, codepage: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, maxbytes: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringbytes: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocument(pub ::windows::core::IUnknown);
impl IDebugDocument {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDocument {
type Vtable = IDebugDocument_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c21_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocument> for ::windows::core::IUnknown {
fn from(value: IDebugDocument) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocument> for ::windows::core::IUnknown {
fn from(value: &IDebugDocument) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocument {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocument {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugDocument> for IDebugDocumentInfo {
fn from(value: IDebugDocument) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocument> for IDebugDocumentInfo {
fn from(value: &IDebugDocument) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for IDebugDocument {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for &IDebugDocument {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocument_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentContext(pub ::windows::core::IUnknown);
impl IDebugDocumentContext {
pub unsafe fn GetDocument(&self) -> ::windows::core::Result<IDebugDocument> {
let mut result__: <IDebugDocument as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugDocument>(result__)
}
pub unsafe fn EnumCodeContexts(&self) -> ::windows::core::Result<IEnumDebugCodeContexts> {
let mut result__: <IEnumDebugCodeContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugCodeContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentContext {
type Vtable = IDebugDocumentContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c28_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentContext> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentContext> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppescc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentHelper32(pub ::windows::core::IUnknown);
impl IDebugDocumentHelper32 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Init<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplication32>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pda: Param0, pszshortname: Param1, pszlongname: Param2, docattr: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi(), pszshortname.into_param().abi(), pszlongname.into_param().abi(), ::core::mem::transmute(docattr)).ok()
}
pub unsafe fn Attach<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentHelper32>>(&self, pddhparent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pddhparent.into_param().abi()).ok()
}
pub unsafe fn Detach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddUnicodeText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psztext: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), psztext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDBCSText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, psztext: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), psztext.into_param().abi()).ok()
}
pub unsafe fn SetDebugDocumentHost<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentHost>>(&self, pddh: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pddh.into_param().abi()).ok()
}
pub unsafe fn AddDeferredText(&self, cchars: u32, dwtextstartcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(cchars), ::core::mem::transmute(dwtextstartcookie)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DefineScriptBlock<'a, Param2: ::windows::core::IntoParam<'a, IActiveScript>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, ulcharoffset: u32, cchars: u32, pas: Param2, fscriptlet: Param3) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcharoffset), ::core::mem::transmute(cchars), pas.into_param().abi(), fscriptlet.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetDefaultTextAttr(&self, statextattr: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(statextattr)).ok()
}
pub unsafe fn SetTextAttributes(&self, ulcharoffset: u32, cchars: u32, pstatextattr: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcharoffset), ::core::mem::transmute(cchars), ::core::mem::transmute(pstatextattr)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLongName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszlongname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), pszlongname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetShortName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszshortname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pszshortname.into_param().abi()).ok()
}
pub unsafe fn SetDocumentAttr(&self, pszattributes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszattributes)).ok()
}
pub unsafe fn GetDebugApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn GetScriptBlockInfo(&self, dwsourcecontext: u32, ppasd: *mut ::core::option::Option<IActiveScript>, picharpos: *mut u32, pcchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ppasd), ::core::mem::transmute(picharpos), ::core::mem::transmute(pcchars)).ok()
}
pub unsafe fn CreateDebugDocumentContext(&self, icharpos: u32, cchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(icharpos), ::core::mem::transmute(cchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn BringDocumentToTop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn BringDocumentContextToTop<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentContext>>(&self, pddc: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), pddc.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentHelper32 {
type Vtable = IDebugDocumentHelper32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c26_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentHelper32> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentHelper32) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentHelper32> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentHelper32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentHelper32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentHelper32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentHelper32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, pszshortname: super::super::super::Foundation::PWSTR, pszlongname: super::super::super::Foundation::PWSTR, docattr: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddhparent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddh: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cchars: u32, dwtextstartcookie: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcharoffset: u32, cchars: u32, pas: ::windows::core::RawPtr, fscriptlet: super::super::super::Foundation::BOOL, pdwsourcecontext: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, statextattr: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcharoffset: u32, cchars: u32, pstatextattr: *const u16) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszlongname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszshortname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszattributes: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdan: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u32, ppasd: *mut ::windows::core::RawPtr, picharpos: *mut u32, pcchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, icharpos: u32, cchars: u32, ppddc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddc: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentHelper64(pub ::windows::core::IUnknown);
impl IDebugDocumentHelper64 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Init<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplication64>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pda: Param0, pszshortname: Param1, pszlongname: Param2, docattr: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi(), pszshortname.into_param().abi(), pszlongname.into_param().abi(), ::core::mem::transmute(docattr)).ok()
}
pub unsafe fn Attach<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentHelper64>>(&self, pddhparent: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pddhparent.into_param().abi()).ok()
}
pub unsafe fn Detach(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddUnicodeText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psztext: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), psztext.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddDBCSText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, psztext: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), psztext.into_param().abi()).ok()
}
pub unsafe fn SetDebugDocumentHost<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentHost>>(&self, pddh: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pddh.into_param().abi()).ok()
}
pub unsafe fn AddDeferredText(&self, cchars: u32, dwtextstartcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(cchars), ::core::mem::transmute(dwtextstartcookie)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DefineScriptBlock<'a, Param2: ::windows::core::IntoParam<'a, IActiveScript>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, ulcharoffset: u32, cchars: u32, pas: Param2, fscriptlet: Param3) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcharoffset), ::core::mem::transmute(cchars), pas.into_param().abi(), fscriptlet.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetDefaultTextAttr(&self, statextattr: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(statextattr)).ok()
}
pub unsafe fn SetTextAttributes(&self, ulcharoffset: u32, cchars: u32, pstatextattr: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcharoffset), ::core::mem::transmute(cchars), ::core::mem::transmute(pstatextattr)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLongName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszlongname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), pszlongname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetShortName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszshortname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pszshortname.into_param().abi()).ok()
}
pub unsafe fn SetDocumentAttr(&self, pszattributes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszattributes)).ok()
}
pub unsafe fn GetDebugApplicationNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn GetScriptBlockInfo(&self, dwsourcecontext: u64, ppasd: *mut ::core::option::Option<IActiveScript>, picharpos: *mut u32, pcchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwsourcecontext), ::core::mem::transmute(ppasd), ::core::mem::transmute(picharpos), ::core::mem::transmute(pcchars)).ok()
}
pub unsafe fn CreateDebugDocumentContext(&self, icharpos: u32, cchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(icharpos), ::core::mem::transmute(cchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
pub unsafe fn BringDocumentToTop(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn BringDocumentContextToTop<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentContext>>(&self, pddc: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), pddc.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentHelper64 {
type Vtable = IDebugDocumentHelper64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc4c7363c_20fd_47f9_bd82_4855e0150871);
}
impl ::core::convert::From<IDebugDocumentHelper64> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentHelper64) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentHelper64> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentHelper64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentHelper64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentHelper64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentHelper64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, pszshortname: super::super::super::Foundation::PWSTR, pszlongname: super::super::super::Foundation::PWSTR, docattr: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddhparent: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztext: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddh: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cchars: u32, dwtextstartcookie: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcharoffset: u32, cchars: u32, pas: ::windows::core::RawPtr, fscriptlet: super::super::super::Foundation::BOOL, pdwsourcecontext: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, statextattr: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcharoffset: u32, cchars: u32, pstatextattr: *const u16) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszlongname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszshortname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszattributes: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdan: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwsourcecontext: u64, ppasd: *mut ::windows::core::RawPtr, picharpos: *mut u32, pcchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, icharpos: u32, cchars: u32, ppddc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pddc: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentHost(pub ::windows::core::IUnknown);
impl IDebugDocumentHost {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDeferredText(&self, dwtextstartcookie: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwtextstartcookie), ::core::mem::transmute(pchartext), ::core::mem::transmute(pstatextattr), ::core::mem::transmute(pcnumchars), ::core::mem::transmute(cmaxchars)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScriptTextAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, unumcodechars: u32, pstrdelimiter: Param2, dwflags: u32, pattr: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(unumcodechars), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), ::core::mem::transmute(pattr)).ok()
}
pub unsafe fn OnCreateDocumentContext(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPathName(&self, pbstrlongname: *mut super::super::super::Foundation::BSTR, pfisoriginalfile: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrlongname), ::core::mem::transmute(pfisoriginalfile)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFileName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn NotifyChanged(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentHost {
type Vtable = IDebugDocumentHost_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c27_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentHost> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentHost) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentHost> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentHost) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentHost_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwtextstartcookie: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, unumcodechars: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, pattr: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppunkouter: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrlongname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pfisoriginalfile: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrshortname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentInfo(pub ::windows::core::IUnknown);
impl IDebugDocumentInfo {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentInfo {
type Vtable = IDebugDocumentInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1f_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentInfo> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentInfo> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentProvider(pub ::windows::core::IUnknown);
impl IDebugDocumentProvider {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetDocument(&self) -> ::windows::core::Result<IDebugDocument> {
let mut result__: <IDebugDocument as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugDocument>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentProvider {
type Vtable = IDebugDocumentProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c20_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentProvider> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentProvider> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugDocumentProvider> for IDebugDocumentInfo {
fn from(value: IDebugDocumentProvider) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentProvider> for IDebugDocumentInfo {
fn from(value: &IDebugDocumentProvider) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for IDebugDocumentProvider {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for &IDebugDocumentProvider {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppssd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentText(pub ::windows::core::IUnknown);
impl IDebugDocumentText {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetDocumentAttributes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSize(&self, pcnumlines: *mut u32, pcnumchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcnumlines), ::core::mem::transmute(pcnumchars)).ok()
}
pub unsafe fn GetPositionOfLine(&self, clinenumber: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(clinenumber), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetLineOfPosition(&self, ccharacterposition: u32, pclinenumber: *mut u32, pccharacteroffsetinline: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(pclinenumber), ::core::mem::transmute(pccharacteroffsetinline)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self, ccharacterposition: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(pchartext), ::core::mem::transmute(pstatextattr), ::core::mem::transmute(pcnumchars), ::core::mem::transmute(cmaxchars)).ok()
}
pub unsafe fn GetPositionOfContext<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentContext>>(&self, psc: Param0, pccharacterposition: *mut u32, cnumchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), psc.into_param().abi(), ::core::mem::transmute(pccharacterposition), ::core::mem::transmute(cnumchars)).ok()
}
pub unsafe fn GetContextOfPosition(&self, ccharacterposition: u32, cnumchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentText {
type Vtable = IDebugDocumentText_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c22_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentText> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentText) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentText> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentText) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugDocumentText> for IDebugDocument {
fn from(value: IDebugDocumentText) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentText> for IDebugDocument {
fn from(value: &IDebugDocumentText) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocument> for IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocument> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocument> for &IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocument> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugDocumentText> for IDebugDocumentInfo {
fn from(value: IDebugDocumentText) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentText> for IDebugDocumentInfo {
fn from(value: &IDebugDocumentText) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for &IDebugDocumentText {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentText_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptextdocattr: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcnumlines: *mut u32, pcnumchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clinenumber: u32, pccharacterposition: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, pclinenumber: *mut u32, pccharacteroffsetinline: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psc: ::windows::core::RawPtr, pccharacterposition: *mut u32, cnumchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumchars: u32, ppsc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentTextAuthor(pub ::windows::core::IUnknown);
impl IDebugDocumentTextAuthor {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self, dnt: DOCUMENTNAMETYPE) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dnt), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentClassId(&self) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
pub unsafe fn GetDocumentAttributes(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSize(&self, pcnumlines: *mut u32, pcnumchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcnumlines), ::core::mem::transmute(pcnumchars)).ok()
}
pub unsafe fn GetPositionOfLine(&self, clinenumber: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(clinenumber), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetLineOfPosition(&self, ccharacterposition: u32, pclinenumber: *mut u32, pccharacteroffsetinline: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(pclinenumber), ::core::mem::transmute(pccharacteroffsetinline)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self, ccharacterposition: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(pchartext), ::core::mem::transmute(pstatextattr), ::core::mem::transmute(pcnumchars), ::core::mem::transmute(cmaxchars)).ok()
}
pub unsafe fn GetPositionOfContext<'a, Param0: ::windows::core::IntoParam<'a, IDebugDocumentContext>>(&self, psc: Param0, pccharacterposition: *mut u32, cnumchars: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), psc.into_param().abi(), ::core::mem::transmute(pccharacterposition), ::core::mem::transmute(cnumchars)).ok()
}
pub unsafe fn GetContextOfPosition(&self, ccharacterposition: u32, cnumchars: u32) -> ::windows::core::Result<IDebugDocumentContext> {
let mut result__: <IDebugDocumentContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumchars), &mut result__).from_abi::<IDebugDocumentContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InsertText<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, ccharacterposition: u32, cnumtoinsert: u32, pchartext: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoinsert), pchartext.into_param().abi()).ok()
}
pub unsafe fn RemoveText(&self, ccharacterposition: u32, cnumtoremove: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoremove)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReplaceText<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, ccharacterposition: u32, cnumtoreplace: u32, pchartext: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoreplace), pchartext.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentTextAuthor {
type Vtable = IDebugDocumentTextAuthor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c24_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentTextAuthor> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentTextAuthor) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentTextAuthor> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentTextAuthor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugDocumentTextAuthor> for IDebugDocumentText {
fn from(value: IDebugDocumentTextAuthor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentTextAuthor> for IDebugDocumentText {
fn from(value: &IDebugDocumentTextAuthor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentText> for IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentText> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentText> for &IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentText> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugDocumentTextAuthor> for IDebugDocument {
fn from(value: IDebugDocumentTextAuthor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentTextAuthor> for IDebugDocument {
fn from(value: &IDebugDocumentTextAuthor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocument> for IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocument> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocument> for &IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocument> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugDocumentTextAuthor> for IDebugDocumentInfo {
fn from(value: IDebugDocumentTextAuthor) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugDocumentTextAuthor> for IDebugDocumentInfo {
fn from(value: &IDebugDocumentTextAuthor) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugDocumentInfo> for &IDebugDocumentTextAuthor {
fn into_param(self) -> ::windows::core::Param<'a, IDebugDocumentInfo> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentTextAuthor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dnt: DOCUMENTNAMETYPE, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsiddocument: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptextdocattr: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcnumlines: *mut u32, pcnumchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clinenumber: u32, pccharacterposition: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, pclinenumber: *mut u32, pccharacteroffsetinline: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, pchartext: super::super::super::Foundation::PWSTR, pstatextattr: *mut u16, pcnumchars: *mut u32, cmaxchars: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psc: ::windows::core::RawPtr, pccharacterposition: *mut u32, cnumchars: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumchars: u32, ppsc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoinsert: u32, pchartext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoremove: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoreplace: u32, pchartext: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentTextEvents(pub ::windows::core::IUnknown);
impl IDebugDocumentTextEvents {
pub unsafe fn onDestroy(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn onInsertText(&self, ccharacterposition: u32, cnumtoinsert: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoinsert)).ok()
}
pub unsafe fn onRemoveText(&self, ccharacterposition: u32, cnumtoremove: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoremove)).ok()
}
pub unsafe fn onReplaceText(&self, ccharacterposition: u32, cnumtoreplace: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoreplace)).ok()
}
pub unsafe fn onUpdateTextAttributes(&self, ccharacterposition: u32, cnumtoupdate: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ccharacterposition), ::core::mem::transmute(cnumtoupdate)).ok()
}
pub unsafe fn onUpdateDocumentAttributes(&self, textdocattr: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(textdocattr)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentTextEvents {
type Vtable = IDebugDocumentTextEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c23_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentTextEvents> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentTextEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentTextEvents> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentTextEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentTextEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentTextEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentTextEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoinsert: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoremove: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoreplace: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ccharacterposition: u32, cnumtoupdate: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, textdocattr: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugDocumentTextExternalAuthor(pub ::windows::core::IUnknown);
impl IDebugDocumentTextExternalAuthor {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPathName(&self, pbstrlongname: *mut super::super::super::Foundation::BSTR, pfisoriginalfile: *mut super::super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrlongname), ::core::mem::transmute(pfisoriginalfile)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFileName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn NotifyChanged(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugDocumentTextExternalAuthor {
type Vtable = IDebugDocumentTextExternalAuthor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c25_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugDocumentTextExternalAuthor> for ::windows::core::IUnknown {
fn from(value: IDebugDocumentTextExternalAuthor) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugDocumentTextExternalAuthor> for ::windows::core::IUnknown {
fn from(value: &IDebugDocumentTextExternalAuthor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugDocumentTextExternalAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugDocumentTextExternalAuthor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugDocumentTextExternalAuthor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrlongname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pfisoriginalfile: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrshortname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugEventCallbacks(pub ::windows::core::IUnknown);
impl IDebugEventCallbacks {
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Breakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Exception(&self, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(exception), ::core::mem::transmute(firstchance)).ok()
}
pub unsafe fn CreateThread(&self, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(dataoffset), ::core::mem::transmute(startoffset)).ok()
}
pub unsafe fn ExitThread(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: Param4, imagename: Param5, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(handle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(initialthreadhandle),
::core::mem::transmute(threaddataoffset),
::core::mem::transmute(startoffset),
)
.ok()
}
pub unsafe fn ExitProcess(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadModule<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: Param3, imagename: Param4, checksum: u32, timedatestamp: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagefilehandle), ::core::mem::transmute(baseoffset), ::core::mem::transmute(modulesize), modulename.into_param().abi(), imagename.into_param().abi(), ::core::mem::transmute(checksum), ::core::mem::transmute(timedatestamp)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, imagebasename: Param0, baseoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), imagebasename.into_param().abi(), ::core::mem::transmute(baseoffset)).ok()
}
pub unsafe fn SystemError(&self, error: u32, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(error), ::core::mem::transmute(level)).ok()
}
pub unsafe fn SessionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn ChangeDebuggeeState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeEngineState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeSymbolState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugEventCallbacks {
type Vtable = IDebugEventCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x337be28b_5036_4d72_b6bf_c45fbb9f2eaa);
}
impl ::core::convert::From<IDebugEventCallbacks> for ::windows::core::IUnknown {
fn from(value: IDebugEventCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugEventCallbacks> for ::windows::core::IUnknown {
fn from(value: &IDebugEventCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugEventCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugEventCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PSTR, imagename: super::super::super::Foundation::PSTR, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PSTR, imagename: super::super::super::Foundation::PSTR, checksum: u32, timedatestamp: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebasename: super::super::super::Foundation::PSTR, baseoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: u32, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugEventCallbacksWide(pub ::windows::core::IUnknown);
impl IDebugEventCallbacksWide {
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Breakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bp.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Exception(&self, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(exception), ::core::mem::transmute(firstchance)).ok()
}
pub unsafe fn CreateThread(&self, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(dataoffset), ::core::mem::transmute(startoffset)).ok()
}
pub unsafe fn ExitThread(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: Param4, imagename: Param5, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(handle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(initialthreadhandle),
::core::mem::transmute(threaddataoffset),
::core::mem::transmute(startoffset),
)
.ok()
}
pub unsafe fn ExitProcess(&self, exitcode: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadModule<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: Param3, imagename: Param4, checksum: u32, timedatestamp: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(imagefilehandle), ::core::mem::transmute(baseoffset), ::core::mem::transmute(modulesize), modulename.into_param().abi(), imagename.into_param().abi(), ::core::mem::transmute(checksum), ::core::mem::transmute(timedatestamp)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagebasename: Param0, baseoffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), imagebasename.into_param().abi(), ::core::mem::transmute(baseoffset)).ok()
}
pub unsafe fn SystemError(&self, error: u32, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(error), ::core::mem::transmute(level)).ok()
}
pub unsafe fn SessionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn ChangeDebuggeeState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeEngineState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
pub unsafe fn ChangeSymbolState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugEventCallbacksWide {
type Vtable = IDebugEventCallbacksWide_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0690e046_9c23_45ac_a04f_987ac29ad0d3);
}
impl ::core::convert::From<IDebugEventCallbacksWide> for ::windows::core::IUnknown {
fn from(value: IDebugEventCallbacksWide) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugEventCallbacksWide> for ::windows::core::IUnknown {
fn from(value: &IDebugEventCallbacksWide) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugEventCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugEventCallbacksWide_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exception: *const EXCEPTION_RECORD64, firstchance: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, dataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebasename: super::super::super::Foundation::PWSTR, baseoffset: u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: u32, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugEventContextCallbacks(pub ::windows::core::IUnknown);
impl IDebugEventContextCallbacks {
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Breakpoint<'a, Param0: ::windows::core::IntoParam<'a, IDebugBreakpoint2>>(&self, bp: Param0, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), bp.into_param().abi(), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Exception(&self, exception: *const EXCEPTION_RECORD64, firstchance: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(exception), ::core::mem::transmute(firstchance), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn CreateThread(&self, handle: u64, dataoffset: u64, startoffset: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(dataoffset), ::core::mem::transmute(startoffset), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn ExitThread(&self, exitcode: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateProcessA<'a, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
imagefilehandle: u64,
handle: u64,
baseoffset: u64,
modulesize: u32,
modulename: Param4,
imagename: Param5,
checksum: u32,
timedatestamp: u32,
initialthreadhandle: u64,
threaddataoffset: u64,
startoffset: u64,
context: *const ::core::ffi::c_void,
contextsize: u32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(handle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(initialthreadhandle),
::core::mem::transmute(threaddataoffset),
::core::mem::transmute(startoffset),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
)
.ok()
}
pub unsafe fn ExitProcess(&self, exitcode: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(exitcode), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadModule<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: Param3, imagename: Param4, checksum: u32, timedatestamp: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(
::core::mem::transmute_copy(self),
::core::mem::transmute(imagefilehandle),
::core::mem::transmute(baseoffset),
::core::mem::transmute(modulesize),
modulename.into_param().abi(),
imagename.into_param().abi(),
::core::mem::transmute(checksum),
::core::mem::transmute(timedatestamp),
::core::mem::transmute(context),
::core::mem::transmute(contextsize),
)
.ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn UnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, imagebasename: Param0, baseoffset: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), imagebasename.into_param().abi(), ::core::mem::transmute(baseoffset), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SystemError(&self, error: u32, level: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(error), ::core::mem::transmute(level), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn SessionStatus(&self, status: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(status)).ok()
}
pub unsafe fn ChangeDebuggeeState(&self, flags: u32, argument: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn ChangeEngineState(&self, flags: u32, argument: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument), ::core::mem::transmute(context), ::core::mem::transmute(contextsize)).ok()
}
pub unsafe fn ChangeSymbolState(&self, flags: u32, argument: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(argument)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugEventContextCallbacks {
type Vtable = IDebugEventContextCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x61a4905b_23f9_4247_b3c5_53d087529ab7);
}
impl ::core::convert::From<IDebugEventContextCallbacks> for ::windows::core::IUnknown {
fn from(value: IDebugEventContextCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugEventContextCallbacks> for ::windows::core::IUnknown {
fn from(value: &IDebugEventContextCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugEventContextCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugEventContextCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugEventContextCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bp: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exception: *const EXCEPTION_RECORD64, firstchance: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, dataoffset: u64, startoffset: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, handle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32, initialthreadhandle: u64, threaddataoffset: u64, startoffset: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, exitcode: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagefilehandle: u64, baseoffset: u64, modulesize: u32, modulename: super::super::super::Foundation::PWSTR, imagename: super::super::super::Foundation::PWSTR, checksum: u32, timedatestamp: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, imagebasename: super::super::super::Foundation::PWSTR, baseoffset: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, error: u32, level: u32, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64, context: *const ::core::ffi::c_void, contextsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, argument: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugExpression(pub ::windows::core::IUnknown);
impl IDebugExpression {
pub unsafe fn Start<'a, Param0: ::windows::core::IntoParam<'a, IDebugExpressionCallBack>>(&self, pdecb: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pdecb.into_param().abi()).ok()
}
pub unsafe fn Abort(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn QueryIsComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetResultAsString(&self, phrresult: *mut ::windows::core::HRESULT, pbstrresult: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(phrresult), ::core::mem::transmute(pbstrresult)).ok()
}
pub unsafe fn GetResultAsDebugProperty(&self, phrresult: *mut ::windows::core::HRESULT, ppdp: *mut ::core::option::Option<IDebugProperty>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(phrresult), ::core::mem::transmute(ppdp)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugExpression {
type Vtable = IDebugExpression_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c14_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugExpression> for ::windows::core::IUnknown {
fn from(value: IDebugExpression) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugExpression> for ::windows::core::IUnknown {
fn from(value: &IDebugExpression) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugExpression {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugExpression {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugExpression_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdecb: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phrresult: *mut ::windows::core::HRESULT, pbstrresult: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phrresult: *mut ::windows::core::HRESULT, ppdp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugExpressionCallBack(pub ::windows::core::IUnknown);
impl IDebugExpressionCallBack {
pub unsafe fn onComplete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugExpressionCallBack {
type Vtable = IDebugExpressionCallBack_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c16_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugExpressionCallBack> for ::windows::core::IUnknown {
fn from(value: IDebugExpressionCallBack) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugExpressionCallBack> for ::windows::core::IUnknown {
fn from(value: &IDebugExpressionCallBack) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugExpressionCallBack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugExpressionCallBack {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugExpressionCallBack_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugExpressionContext(pub ::windows::core::IUnknown);
impl IDebugExpressionContext {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ParseLanguageText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrcode: Param0, nradix: u32, pstrdelimiter: Param2, dwflags: u32) -> ::windows::core::Result<IDebugExpression> {
let mut result__: <IDebugExpression as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstrcode.into_param().abi(), ::core::mem::transmute(nradix), pstrdelimiter.into_param().abi(), ::core::mem::transmute(dwflags), &mut result__).from_abi::<IDebugExpression>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguageInfo(&self, pbstrlanguagename: *mut super::super::super::Foundation::BSTR, planguageid: *mut ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrlanguagename), ::core::mem::transmute(planguageid)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugExpressionContext {
type Vtable = IDebugExpressionContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c15_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugExpressionContext> for ::windows::core::IUnknown {
fn from(value: IDebugExpressionContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugExpressionContext> for ::windows::core::IUnknown {
fn from(value: &IDebugExpressionContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugExpressionContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugExpressionContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugExpressionContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrcode: super::super::super::Foundation::PWSTR, nradix: u32, pstrdelimiter: super::super::super::Foundation::PWSTR, dwflags: u32, ppe: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrlanguagename: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, planguageid: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugExtendedProperty(pub ::windows::core::IUnknown);
impl IDebugExtendedProperty {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyInfo(&self, dwfieldspec: u32, nradix: u32) -> ::windows::core::Result<DebugPropertyInfo> {
let mut result__: <DebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), &mut result__).from_abi::<DebugPropertyInfo>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows::core::GUID, rgvar: *mut super::super::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(cinfos), ::core::mem::transmute(rgguidextendedinfo), ::core::mem::transmute(rgvar)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValueAsString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszvalue: Param0, nradix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvalue.into_param().abi(), ::core::mem::transmute(nradix)).ok()
}
pub unsafe fn EnumMembers(&self, dwfieldspec: u32, nradix: u32, refiid: *const ::windows::core::GUID) -> ::windows::core::Result<IEnumDebugPropertyInfo> {
let mut result__: <IEnumDebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), ::core::mem::transmute(refiid), &mut result__).from_abi::<IEnumDebugPropertyInfo>(result__)
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugProperty>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
pub unsafe fn GetExtendedPropertyInfo(&self, dwfieldspec: u32, nradix: u32) -> ::windows::core::Result<ExtendedDebugPropertyInfo> {
let mut result__: <ExtendedDebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), &mut result__).from_abi::<ExtendedDebugPropertyInfo>(result__)
}
pub unsafe fn EnumExtendedMembers(&self, dwfieldspec: u32, nradix: u32) -> ::windows::core::Result<IEnumDebugExtendedPropertyInfo> {
let mut result__: <IEnumDebugExtendedPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), &mut result__).from_abi::<IEnumDebugExtendedPropertyInfo>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugExtendedProperty {
type Vtable = IDebugExtendedProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c52_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugExtendedProperty> for ::windows::core::IUnknown {
fn from(value: IDebugExtendedProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugExtendedProperty> for ::windows::core::IUnknown {
fn from(value: &IDebugExtendedProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugExtendedProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugExtendedProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugExtendedProperty> for IDebugProperty {
fn from(value: IDebugExtendedProperty) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugExtendedProperty> for IDebugProperty {
fn from(value: &IDebugExtendedProperty) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugProperty> for IDebugExtendedProperty {
fn into_param(self) -> ::windows::core::Param<'a, IDebugProperty> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugProperty> for &IDebugExtendedProperty {
fn into_param(self) -> ::windows::core::Param<'a, IDebugProperty> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugExtendedProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut ::core::mem::ManuallyDrop<DebugPropertyInfo>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cinfos: u32, rgguidextendedinfo: *const ::windows::core::GUID, rgvar: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvalue: super::super::super::Foundation::PWSTR, nradix: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, refiid: *const ::windows::core::GUID, ppepi: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdebugprop: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, pextendedpropertyinfo: *mut ::core::mem::ManuallyDrop<ExtendedDebugPropertyInfo>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, ppeepi: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugFormatter(pub ::windows::core::IUnknown);
impl IDebugFormatter {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetStringForVariant(&self, pvar: *const super::super::Com::VARIANT, nradix: u32) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvar), ::core::mem::transmute(nradix), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetVariantForString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwstrvalue: Param0) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pwstrvalue.into_param().abi(), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetStringForVarType(&self, vt: u16, ptdescarraytype: *const super::super::Com::TYPEDESC) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(vt), ::core::mem::transmute(ptdescarraytype), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugFormatter {
type Vtable = IDebugFormatter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c05_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugFormatter> for ::windows::core::IUnknown {
fn from(value: IDebugFormatter) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugFormatter> for ::windows::core::IUnknown {
fn from(value: &IDebugFormatter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugFormatter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugFormatter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugFormatter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvar: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, nradix: u32, pbstrvalue: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwstrvalue: super::super::super::Foundation::PWSTR, pvar: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, vt: u16, ptdescarraytype: *const super::super::Com::TYPEDESC, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHelper(pub ::windows::core::IUnknown);
impl IDebugHelper {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreatePropertyBrowser<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IDebugApplicationThread>>(&self, pvar: *const super::super::Com::VARIANT, bstrname: Param1, pdat: Param2) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvar), bstrname.into_param().abi(), pdat.into_param().abi(), &mut result__).from_abi::<IDebugProperty>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreatePropertyBrowserEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IDebugApplicationThread>, Param3: ::windows::core::IntoParam<'a, IDebugFormatter>>(&self, pvar: *const super::super::Com::VARIANT, bstrname: Param1, pdat: Param2, pdf: Param3) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pvar), bstrname.into_param().abi(), pdat.into_param().abi(), pdf.into_param().abi(), &mut result__).from_abi::<IDebugProperty>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CreateSimpleConnectionPoint<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>>(&self, pdisp: Param0) -> ::windows::core::Result<ISimpleConnectionPoint> {
let mut result__: <ISimpleConnectionPoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pdisp.into_param().abi(), &mut result__).from_abi::<ISimpleConnectionPoint>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHelper {
type Vtable = IDebugHelper_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c3f_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugHelper> for ::windows::core::IUnknown {
fn from(value: IDebugHelper) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHelper> for ::windows::core::IUnknown {
fn from(value: &IDebugHelper) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHelper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHelper {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHelper_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvar: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, bstrname: super::super::super::Foundation::PWSTR, pdat: ::windows::core::RawPtr, ppdob: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvar: *const ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, bstrname: super::super::super::Foundation::PWSTR, pdat: ::windows::core::RawPtr, pdf: ::windows::core::RawPtr, ppdob: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdisp: ::windows::core::RawPtr, ppscp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHost(pub ::windows::core::IUnknown);
impl IDebugHost {
pub unsafe fn GetHostDefinedInterface(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn GetCurrentContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
pub unsafe fn GetDefaultMetadata(&self) -> ::windows::core::Result<IKeyStore> {
let mut result__: <IKeyStore as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IKeyStore>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHost {
type Vtable = IDebugHost_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8c74943_6b2c_4eeb_b5c5_35d378a6d99d);
}
impl ::core::convert::From<IDebugHost> for ::windows::core::IUnknown {
fn from(value: IDebugHost) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHost> for ::windows::core::IUnknown {
fn from(value: &IDebugHost) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHost_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hostunk: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, defaultmetadatastore: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostBaseClass(pub ::windows::core::IUnknown);
impl IDebugHostBaseClass {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostBaseClass {
type Vtable = IDebugHostBaseClass_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb94d57d2_390b_40f7_b5b4_b6db897d974b);
}
impl ::core::convert::From<IDebugHostBaseClass> for ::windows::core::IUnknown {
fn from(value: IDebugHostBaseClass) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostBaseClass> for ::windows::core::IUnknown {
fn from(value: &IDebugHostBaseClass) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostBaseClass {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostBaseClass {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostBaseClass> for IDebugHostSymbol {
fn from(value: IDebugHostBaseClass) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostBaseClass> for IDebugHostSymbol {
fn from(value: &IDebugHostBaseClass) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostBaseClass {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostBaseClass {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostBaseClass_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostConstant(pub ::windows::core::IUnknown);
impl IDebugHostConstant {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetValue(&self) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostConstant {
type Vtable = IDebugHostConstant_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62787edc_fa76_4690_bd71_5e8c3e2937ec);
}
impl ::core::convert::From<IDebugHostConstant> for ::windows::core::IUnknown {
fn from(value: IDebugHostConstant) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostConstant> for ::windows::core::IUnknown {
fn from(value: &IDebugHostConstant) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostConstant {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostConstant {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostConstant> for IDebugHostSymbol {
fn from(value: IDebugHostConstant) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostConstant> for IDebugHostSymbol {
fn from(value: &IDebugHostConstant) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostConstant {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostConstant {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostConstant_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostContext(pub ::windows::core::IUnknown);
impl IDebugHostContext {
pub unsafe fn IsEqualTo<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>>(&self, pcontext: Param0) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcontext.into_param().abi(), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostContext {
type Vtable = IDebugHostContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa68c70d8_5ec0_46e5_b775_3134a48ea2e3);
}
impl ::core::convert::From<IDebugHostContext> for ::windows::core::IUnknown {
fn from(value: IDebugHostContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostContext> for ::windows::core::IUnknown {
fn from(value: &IDebugHostContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcontext: ::windows::core::RawPtr, pisequal: *mut bool) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostData(pub ::windows::core::IUnknown);
impl IDebugHostData {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetLocationKind(&self) -> ::windows::core::Result<LocationKind> {
let mut result__: <LocationKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<LocationKind>(result__)
}
pub unsafe fn GetLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetValue(&self) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostData {
type Vtable = IDebugHostData_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa3d64993_826c_44fa_897d_926f2fe7ad0b);
}
impl ::core::convert::From<IDebugHostData> for ::windows::core::IUnknown {
fn from(value: IDebugHostData) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostData> for ::windows::core::IUnknown {
fn from(value: &IDebugHostData) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostData {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostData {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostData> for IDebugHostSymbol {
fn from(value: IDebugHostData) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostData> for IDebugHostSymbol {
fn from(value: &IDebugHostData) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostData {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostData {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostData_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, locationkind: *mut LocationKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: *mut Location) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostErrorSink(pub ::windows::core::IUnknown);
impl IDebugHostErrorSink {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReportError<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, errclass: ErrorClass, hrerror: ::windows::core::HRESULT, message: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(errclass), ::core::mem::transmute(hrerror), message.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostErrorSink {
type Vtable = IDebugHostErrorSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8ff0f0b_fce9_467e_8bb3_5d69ef109c00);
}
impl ::core::convert::From<IDebugHostErrorSink> for ::windows::core::IUnknown {
fn from(value: IDebugHostErrorSink) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostErrorSink> for ::windows::core::IUnknown {
fn from(value: &IDebugHostErrorSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostErrorSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostErrorSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostErrorSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, errclass: ErrorClass, hrerror: ::windows::core::HRESULT, message: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostEvaluator(pub ::windows::core::IUnknown);
impl IDebugHostEvaluator {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateExpression<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, context: Param0, expression: Param1, bindingcontext: Param2, result: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), context.into_param().abi(), expression.into_param().abi(), bindingcontext.into_param().abi(), ::core::mem::transmute(result), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateExtendedExpression<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, context: Param0, expression: Param1, bindingcontext: Param2, result: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), context.into_param().abi(), expression.into_param().abi(), bindingcontext.into_param().abi(), ::core::mem::transmute(result), ::core::mem::transmute(metadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostEvaluator {
type Vtable = IDebugHostEvaluator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0fef9a21_577e_4997_ac7b_1c4883241d99);
}
impl ::core::convert::From<IDebugHostEvaluator> for ::windows::core::IUnknown {
fn from(value: IDebugHostEvaluator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostEvaluator> for ::windows::core::IUnknown {
fn from(value: &IDebugHostEvaluator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostEvaluator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostEvaluator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostEvaluator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, bindingcontext: ::windows::core::RawPtr, result: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, bindingcontext: ::windows::core::RawPtr, result: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostEvaluator2(pub ::windows::core::IUnknown);
impl IDebugHostEvaluator2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateExpression<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, context: Param0, expression: Param1, bindingcontext: Param2, result: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), context.into_param().abi(), expression.into_param().abi(), bindingcontext.into_param().abi(), ::core::mem::transmute(result), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EvaluateExtendedExpression<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, context: Param0, expression: Param1, bindingcontext: Param2, result: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), context.into_param().abi(), expression.into_param().abi(), bindingcontext.into_param().abi(), ::core::mem::transmute(result), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn AssignTo<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, assignmentreference: Param0, assignmentvalue: Param1, assignmentresult: *mut ::core::option::Option<IModelObject>, assignmentmetadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), assignmentreference.into_param().abi(), assignmentvalue.into_param().abi(), ::core::mem::transmute(assignmentresult), ::core::mem::transmute(assignmentmetadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostEvaluator2 {
type Vtable = IDebugHostEvaluator2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa117a435_1fb4_4092_a2ab_a929576c1e87);
}
impl ::core::convert::From<IDebugHostEvaluator2> for ::windows::core::IUnknown {
fn from(value: IDebugHostEvaluator2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostEvaluator2> for ::windows::core::IUnknown {
fn from(value: &IDebugHostEvaluator2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostEvaluator2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostEvaluator2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostEvaluator2> for IDebugHostEvaluator {
fn from(value: IDebugHostEvaluator2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostEvaluator2> for IDebugHostEvaluator {
fn from(value: &IDebugHostEvaluator2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostEvaluator> for IDebugHostEvaluator2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostEvaluator> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostEvaluator> for &IDebugHostEvaluator2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostEvaluator> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostEvaluator2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, bindingcontext: ::windows::core::RawPtr, result: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, expression: super::super::super::Foundation::PWSTR, bindingcontext: ::windows::core::RawPtr, result: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, assignmentreference: ::windows::core::RawPtr, assignmentvalue: ::windows::core::RawPtr, assignmentresult: *mut ::windows::core::RawPtr, assignmentmetadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostExtensibility(pub ::windows::core::IUnknown);
impl IDebugHostExtensibility {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateFunctionAlias<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, aliasname: Param0, functionobject: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), aliasname.into_param().abi(), functionobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DestroyFunctionAlias<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, aliasname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), aliasname.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostExtensibility {
type Vtable = IDebugHostExtensibility_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c2b24e1_11d0_4f86_8ae5_4df166f73253);
}
impl ::core::convert::From<IDebugHostExtensibility> for ::windows::core::IUnknown {
fn from(value: IDebugHostExtensibility) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostExtensibility> for ::windows::core::IUnknown {
fn from(value: &IDebugHostExtensibility) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostExtensibility {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostExtensibility {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostExtensibility_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, aliasname: super::super::super::Foundation::PWSTR, functionobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, aliasname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostField(pub ::windows::core::IUnknown);
impl IDebugHostField {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetLocationKind(&self) -> ::windows::core::Result<LocationKind> {
let mut result__: <LocationKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<LocationKind>(result__)
}
pub unsafe fn GetOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetValue(&self) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostField {
type Vtable = IDebugHostField_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe06f6495_16bc_4cc9_b11d_2a6b23fa72f3);
}
impl ::core::convert::From<IDebugHostField> for ::windows::core::IUnknown {
fn from(value: IDebugHostField) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostField> for ::windows::core::IUnknown {
fn from(value: &IDebugHostField) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostField {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostField {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostField> for IDebugHostSymbol {
fn from(value: IDebugHostField) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostField> for IDebugHostSymbol {
fn from(value: &IDebugHostField) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostField {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostField {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostField_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, locationkind: *mut LocationKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: *mut Location) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostMemory(pub ::windows::core::IUnknown);
impl IDebugHostMemory {
pub unsafe fn ReadBytes<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, buffer: *mut ::core::ffi::c_void, buffersize: u64, bytesread: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBytes<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, buffer: *const ::core::ffi::c_void, buffersize: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadPointers<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, count: u64, pointers: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(count), ::core::mem::transmute(pointers)).ok()
}
pub unsafe fn WritePointers<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, count: u64, pointers: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(count), ::core::mem::transmute(pointers)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDisplayStringForLocation<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, verbose: u8) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(verbose), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostMemory {
type Vtable = IDebugHostMemory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x212149c9_9183_4a3e_b00e_4fd1dc95339b);
}
impl ::core::convert::From<IDebugHostMemory> for ::windows::core::IUnknown {
fn from(value: IDebugHostMemory) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostMemory> for ::windows::core::IUnknown {
fn from(value: &IDebugHostMemory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostMemory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostMemory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostMemory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, buffer: *mut ::core::ffi::c_void, buffersize: u64, bytesread: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, buffer: *const ::core::ffi::c_void, buffersize: u64, byteswritten: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, count: u64, pointers: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, count: u64, pointers: *const u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, verbose: u8, locationname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostMemory2(pub ::windows::core::IUnknown);
impl IDebugHostMemory2 {
pub unsafe fn ReadBytes<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, buffer: *mut ::core::ffi::c_void, buffersize: u64, bytesread: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteBytes<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, buffer: *const ::core::ffi::c_void, buffersize: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ReadPointers<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, count: u64, pointers: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(count), ::core::mem::transmute(pointers)).ok()
}
pub unsafe fn WritePointers<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, count: u64, pointers: *const u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(count), ::core::mem::transmute(pointers)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDisplayStringForLocation<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1, verbose: u8) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), ::core::mem::transmute(verbose), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn LinearizeLocation<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, location: Param1) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), context.into_param().abi(), location.into_param().abi(), &mut result__).from_abi::<Location>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostMemory2 {
type Vtable = IDebugHostMemory2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeea033de_38f6_416b_a251_1d3771001270);
}
impl ::core::convert::From<IDebugHostMemory2> for ::windows::core::IUnknown {
fn from(value: IDebugHostMemory2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostMemory2> for ::windows::core::IUnknown {
fn from(value: &IDebugHostMemory2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostMemory2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostMemory2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostMemory2> for IDebugHostMemory {
fn from(value: IDebugHostMemory2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostMemory2> for IDebugHostMemory {
fn from(value: &IDebugHostMemory2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostMemory> for IDebugHostMemory2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostMemory> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostMemory> for &IDebugHostMemory2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostMemory> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostMemory2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, buffer: *mut ::core::ffi::c_void, buffersize: u64, bytesread: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, buffer: *const ::core::ffi::c_void, buffersize: u64, byteswritten: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, count: u64, pointers: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, count: u64, pointers: *const u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, verbose: u8, locationname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, location: Location, plinearizedlocation: *mut Location) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostModule(pub ::windows::core::IUnknown);
impl IDebugHostModule {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImageName(&self, allowpath: u8) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(allowpath), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetBaseLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
pub unsafe fn GetVersion(&self, fileversion: *mut u64, productversion: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(fileversion), ::core::mem::transmute(productversion)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindTypeByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, typename: Param0) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), typename.into_param().abi(), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn FindSymbolByRVA(&self, rva: u64) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(rva), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSymbolByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbolname: Param0) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), symbolname.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostModule {
type Vtable = IDebugHostModule_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9ba3e18_d070_4378_bbd0_34613b346e1e);
}
impl ::core::convert::From<IDebugHostModule> for ::windows::core::IUnknown {
fn from(value: IDebugHostModule) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostModule> for ::windows::core::IUnknown {
fn from(value: &IDebugHostModule) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostModule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostModule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostModule> for IDebugHostSymbol {
fn from(value: IDebugHostModule) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostModule> for IDebugHostSymbol {
fn from(value: &IDebugHostModule) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostModule {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostModule {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostModule_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allowpath: u8, imagename: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modulebaselocation: *mut Location) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fileversion: *mut u64, productversion: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typename: super::super::super::Foundation::PWSTR, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rva: u64, symbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: super::super::super::Foundation::PWSTR, symbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostModule2(pub ::windows::core::IUnknown);
impl IDebugHostModule2 {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImageName(&self, allowpath: u8) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(allowpath), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetBaseLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
pub unsafe fn GetVersion(&self, fileversion: *mut u64, productversion: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(fileversion), ::core::mem::transmute(productversion)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindTypeByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, typename: Param0) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), typename.into_param().abi(), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn FindSymbolByRVA(&self, rva: u64) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(rva), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSymbolByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbolname: Param0) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), symbolname.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
pub unsafe fn FindContainingSymbolByRVA(&self, rva: u64, symbol: *mut ::core::option::Option<IDebugHostSymbol>, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(rva), ::core::mem::transmute(symbol), ::core::mem::transmute(offset)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostModule2 {
type Vtable = IDebugHostModule2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb51887e8_bcd0_4e8f_a8c7_434398b78c37);
}
impl ::core::convert::From<IDebugHostModule2> for ::windows::core::IUnknown {
fn from(value: IDebugHostModule2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostModule2> for ::windows::core::IUnknown {
fn from(value: &IDebugHostModule2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostModule2> for IDebugHostModule {
fn from(value: IDebugHostModule2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostModule2> for IDebugHostModule {
fn from(value: &IDebugHostModule2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostModule> for IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostModule> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostModule> for &IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostModule> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugHostModule2> for IDebugHostSymbol {
fn from(value: IDebugHostModule2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostModule2> for IDebugHostSymbol {
fn from(value: &IDebugHostModule2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostModule2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostModule2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allowpath: u8, imagename: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modulebaselocation: *mut Location) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fileversion: *mut u64, productversion: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typename: super::super::super::Foundation::PWSTR, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rva: u64, symbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: super::super::super::Foundation::PWSTR, symbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rva: u64, symbol: *mut ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostModuleSignature(pub ::windows::core::IUnknown);
impl IDebugHostModuleSignature {
pub unsafe fn IsMatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostModule>>(&self, pmodule: Param0) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pmodule.into_param().abi(), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostModuleSignature {
type Vtable = IDebugHostModuleSignature_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x31e53a5a_01ee_4bbb_b899_4b46ae7d595c);
}
impl ::core::convert::From<IDebugHostModuleSignature> for ::windows::core::IUnknown {
fn from(value: IDebugHostModuleSignature) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostModuleSignature> for ::windows::core::IUnknown {
fn from(value: &IDebugHostModuleSignature) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostModuleSignature {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostModuleSignature {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostModuleSignature_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmodule: ::windows::core::RawPtr, ismatch: *mut bool) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostPublic(pub ::windows::core::IUnknown);
impl IDebugHostPublic {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetLocationKind(&self) -> ::windows::core::Result<LocationKind> {
let mut result__: <LocationKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<LocationKind>(result__)
}
pub unsafe fn GetLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostPublic {
type Vtable = IDebugHostPublic_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c597ac9_fb4d_4f6d_9f39_22488539f8f4);
}
impl ::core::convert::From<IDebugHostPublic> for ::windows::core::IUnknown {
fn from(value: IDebugHostPublic) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostPublic> for ::windows::core::IUnknown {
fn from(value: &IDebugHostPublic) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostPublic {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostPublic {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostPublic> for IDebugHostSymbol {
fn from(value: IDebugHostPublic) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostPublic> for IDebugHostSymbol {
fn from(value: &IDebugHostPublic) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostPublic {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostPublic {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostPublic_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, locationkind: *mut LocationKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: *mut Location) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostScriptHost(pub ::windows::core::IUnknown);
impl IDebugHostScriptHost {
pub unsafe fn CreateContext<'a, Param0: ::windows::core::IntoParam<'a, IDataModelScript>>(&self, script: Param0) -> ::windows::core::Result<IDataModelScriptHostContext> {
let mut result__: <IDataModelScriptHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), script.into_param().abi(), &mut result__).from_abi::<IDataModelScriptHostContext>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostScriptHost {
type Vtable = IDebugHostScriptHost_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb70334a4_b92c_4570_93a1_d3eb686649a0);
}
impl ::core::convert::From<IDebugHostScriptHost> for ::windows::core::IUnknown {
fn from(value: IDebugHostScriptHost) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostScriptHost> for ::windows::core::IUnknown {
fn from(value: &IDebugHostScriptHost) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostScriptHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostScriptHost {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostScriptHost_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, script: ::windows::core::RawPtr, scriptcontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostStatus(pub ::windows::core::IUnknown);
impl IDebugHostStatus {
pub unsafe fn PollUserInterrupt(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostStatus {
type Vtable = IDebugHostStatus_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f3e1ce2_86b2_4c7a_9c65_d0a9d0eecf44);
}
impl ::core::convert::From<IDebugHostStatus> for ::windows::core::IUnknown {
fn from(value: IDebugHostStatus) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostStatus> for ::windows::core::IUnknown {
fn from(value: &IDebugHostStatus) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostStatus_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interruptrequested: *mut bool) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostSymbol(pub ::windows::core::IUnknown);
impl IDebugHostSymbol {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostSymbol {
type Vtable = IDebugHostSymbol_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f819103_87de_4e96_8277_e05cd441fb22);
}
impl ::core::convert::From<IDebugHostSymbol> for ::windows::core::IUnknown {
fn from(value: IDebugHostSymbol) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostSymbol> for ::windows::core::IUnknown {
fn from(value: &IDebugHostSymbol) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostSymbol {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostSymbol {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostSymbol_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostSymbol2(pub ::windows::core::IUnknown);
impl IDebugHostSymbol2 {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<LanguageKind> {
let mut result__: <LanguageKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<LanguageKind>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostSymbol2 {
type Vtable = IDebugHostSymbol2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x21515b67_6720_4257_8a68_077dc944471c);
}
impl ::core::convert::From<IDebugHostSymbol2> for ::windows::core::IUnknown {
fn from(value: IDebugHostSymbol2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostSymbol2> for ::windows::core::IUnknown {
fn from(value: &IDebugHostSymbol2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostSymbol2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostSymbol2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostSymbol2> for IDebugHostSymbol {
fn from(value: IDebugHostSymbol2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostSymbol2> for IDebugHostSymbol {
fn from(value: &IDebugHostSymbol2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostSymbol2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostSymbol2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostSymbol2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pkind: *mut LanguageKind) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostSymbolEnumerator(pub ::windows::core::IUnknown);
impl IDebugHostSymbolEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetNext(&self) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostSymbolEnumerator {
type Vtable = IDebugHostSymbolEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x28d96c86_10a3_4976_b14e_eaef4790aa1f);
}
impl ::core::convert::From<IDebugHostSymbolEnumerator> for ::windows::core::IUnknown {
fn from(value: IDebugHostSymbolEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostSymbolEnumerator> for ::windows::core::IUnknown {
fn from(value: &IDebugHostSymbolEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostSymbolEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostSymbolEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostSymbolEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostSymbols(pub ::windows::core::IUnknown);
impl IDebugHostSymbols {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateModuleSignature<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pwszmodulename: Param0, pwszminversion: Param1, pwszmaxversion: Param2) -> ::windows::core::Result<IDebugHostModuleSignature> {
let mut result__: <IDebugHostModuleSignature as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pwszmodulename.into_param().abi(), pwszminversion.into_param().abi(), pwszmaxversion.into_param().abi(), &mut result__).from_abi::<IDebugHostModuleSignature>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateTypeSignature<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IDebugHostModule>>(&self, signaturespecification: Param0, module: Param1) -> ::windows::core::Result<IDebugHostTypeSignature> {
let mut result__: <IDebugHostTypeSignature as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), signaturespecification.into_param().abi(), module.into_param().abi(), &mut result__).from_abi::<IDebugHostTypeSignature>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateTypeSignatureForModuleRange<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
&self,
signaturespecification: Param0,
modulename: Param1,
minversion: Param2,
maxversion: Param3,
) -> ::windows::core::Result<IDebugHostTypeSignature> {
let mut result__: <IDebugHostTypeSignature as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), signaturespecification.into_param().abi(), modulename.into_param().abi(), minversion.into_param().abi(), maxversion.into_param().abi(), &mut result__).from_abi::<IDebugHostTypeSignature>(result__)
}
pub unsafe fn EnumerateModules<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>>(&self, context: Param0) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), context.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindModuleByName<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, context: Param0, modulename: Param1) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), context.into_param().abi(), modulename.into_param().abi(), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn FindModuleByLocation<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>>(&self, context: Param0, modulelocation: Param1) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), context.into_param().abi(), modulelocation.into_param().abi(), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn GetMostDerivedObject<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostContext>, Param1: ::windows::core::IntoParam<'a, Location>, Param2: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, pcontext: Param0, location: Param1, objecttype: Param2, derivedlocation: *mut Location, derivedtype: *mut ::core::option::Option<IDebugHostType>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcontext.into_param().abi(), location.into_param().abi(), objecttype.into_param().abi(), ::core::mem::transmute(derivedlocation), ::core::mem::transmute(derivedtype)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugHostSymbols {
type Vtable = IDebugHostSymbols_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x854fd751_c2e1_4eb2_b525_6619cb97a588);
}
impl ::core::convert::From<IDebugHostSymbols> for ::windows::core::IUnknown {
fn from(value: IDebugHostSymbols) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostSymbols> for ::windows::core::IUnknown {
fn from(value: &IDebugHostSymbols) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostSymbols {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostSymbols {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostSymbols_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwszmodulename: super::super::super::Foundation::PWSTR, pwszminversion: super::super::super::Foundation::PWSTR, pwszmaxversion: super::super::super::Foundation::PWSTR, ppmodulesignature: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, signaturespecification: super::super::super::Foundation::PWSTR, module: ::windows::core::RawPtr, typesignature: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, signaturespecification: super::super::super::Foundation::PWSTR, modulename: super::super::super::Foundation::PWSTR, minversion: super::super::super::Foundation::PWSTR, maxversion: super::super::super::Foundation::PWSTR, typesignature: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, moduleenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, modulename: super::super::super::Foundation::PWSTR, module: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: ::windows::core::RawPtr, modulelocation: Location, module: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcontext: ::windows::core::RawPtr, location: Location, objecttype: ::windows::core::RawPtr, derivedlocation: *mut Location, derivedtype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostType(pub ::windows::core::IUnknown);
impl IDebugHostType {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetTypeKind(&self) -> ::windows::core::Result<TypeKind> {
let mut result__: <TypeKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<TypeKind>(result__)
}
pub unsafe fn GetSize(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetBaseType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetHashCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetIntrinsicType(&self, intrinsickind: *mut IntrinsicKind, carriertype: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(intrinsickind), ::core::mem::transmute(carriertype)).ok()
}
pub unsafe fn GetBitField(&self, lsboffield: *mut u32, lengthoffield: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(lsboffield), ::core::mem::transmute(lengthoffield)).ok()
}
pub unsafe fn GetPointerKind(&self) -> ::windows::core::Result<PointerKind> {
let mut result__: <PointerKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<PointerKind>(result__)
}
pub unsafe fn GetMemberType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn CreatePointerTo(&self, kind: PointerKind) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetArrayDimensionality(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetArrayDimensions(&self, dimensions: u64, pdimensions: *mut ArrayDimension) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(dimensions), ::core::mem::transmute(pdimensions)).ok()
}
pub unsafe fn CreateArrayOf(&self, dimensions: u64, pdimensions: *const ArrayDimension) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(dimensions), ::core::mem::transmute(pdimensions), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetFunctionCallingConvention(&self) -> ::windows::core::Result<CallingConventionKind> {
let mut result__: <CallingConventionKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), &mut result__).from_abi::<CallingConventionKind>(result__)
}
pub unsafe fn GetFunctionReturnType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetFunctionParameterTypeCount(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetFunctionParameterTypeAt(&self, i: u64) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(i), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn IsGeneric(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetGenericArgumentCount(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetGenericArgumentAt(&self, i: u64) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(i), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostType {
type Vtable = IDebugHostType_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3aadc353_2b14_4abb_9893_5e03458e07ee);
}
impl ::core::convert::From<IDebugHostType> for ::windows::core::IUnknown {
fn from(value: IDebugHostType) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostType> for ::windows::core::IUnknown {
fn from(value: &IDebugHostType) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostType {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostType> for IDebugHostSymbol {
fn from(value: IDebugHostType) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostType> for IDebugHostSymbol {
fn from(value: &IDebugHostType) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostType {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostType {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostType_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut TypeKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, basetype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hashcode: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, intrinsickind: *mut IntrinsicKind, carriertype: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lsboffield: *mut u32, lengthoffield: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pointerkind: *mut PointerKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, membertype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: PointerKind, newtype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, arraydimensionality: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dimensions: u64, pdimensions: *mut ArrayDimension) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dimensions: u64, pdimensions: *const ArrayDimension, newtype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, conventionkind: *mut CallingConventionKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, returntype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, i: u64, parametertype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isgeneric: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, argcount: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, i: u64, argument: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostType2(pub ::windows::core::IUnknown);
impl IDebugHostType2 {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateChildren<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1) -> ::windows::core::Result<IDebugHostSymbolEnumerator> {
let mut result__: <IDebugHostSymbolEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), &mut result__).from_abi::<IDebugHostSymbolEnumerator>(result__)
}
pub unsafe fn GetSymbolKind(&self) -> ::windows::core::Result<SymbolKind> {
let mut result__: <SymbolKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SymbolKind>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetContainingModule(&self) -> ::windows::core::Result<IDebugHostModule> {
let mut result__: <IDebugHostModule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostModule>(result__)
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostSymbol>>(&self, pcomparisonsymbol: Param0, comparisonflags: u32) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pcomparisonsymbol.into_param().abi(), ::core::mem::transmute(comparisonflags), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetTypeKind(&self) -> ::windows::core::Result<TypeKind> {
let mut result__: <TypeKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<TypeKind>(result__)
}
pub unsafe fn GetSize(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetBaseType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetHashCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetIntrinsicType(&self, intrinsickind: *mut IntrinsicKind, carriertype: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(intrinsickind), ::core::mem::transmute(carriertype)).ok()
}
pub unsafe fn GetBitField(&self, lsboffield: *mut u32, lengthoffield: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(lsboffield), ::core::mem::transmute(lengthoffield)).ok()
}
pub unsafe fn GetPointerKind(&self) -> ::windows::core::Result<PointerKind> {
let mut result__: <PointerKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<PointerKind>(result__)
}
pub unsafe fn GetMemberType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn CreatePointerTo(&self, kind: PointerKind) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetArrayDimensionality(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetArrayDimensions(&self, dimensions: u64, pdimensions: *mut ArrayDimension) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(dimensions), ::core::mem::transmute(pdimensions)).ok()
}
pub unsafe fn CreateArrayOf(&self, dimensions: u64, pdimensions: *const ArrayDimension) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(dimensions), ::core::mem::transmute(pdimensions), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetFunctionCallingConvention(&self) -> ::windows::core::Result<CallingConventionKind> {
let mut result__: <CallingConventionKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), &mut result__).from_abi::<CallingConventionKind>(result__)
}
pub unsafe fn GetFunctionReturnType(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetFunctionParameterTypeCount(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetFunctionParameterTypeAt(&self, i: u64) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(i), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn IsGeneric(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetGenericArgumentCount(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetGenericArgumentAt(&self, i: u64) -> ::windows::core::Result<IDebugHostSymbol> {
let mut result__: <IDebugHostSymbol as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(i), &mut result__).from_abi::<IDebugHostSymbol>(result__)
}
pub unsafe fn IsTypedef(&self) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), &mut result__).from_abi::<bool>(result__)
}
pub unsafe fn GetTypedefBaseType(&self) -> ::windows::core::Result<IDebugHostType2> {
let mut result__: <IDebugHostType2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType2>(result__)
}
pub unsafe fn GetTypedefFinalBaseType(&self) -> ::windows::core::Result<IDebugHostType2> {
let mut result__: <IDebugHostType2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType2>(result__)
}
pub unsafe fn GetFunctionVarArgsKind(&self) -> ::windows::core::Result<VarArgsKind> {
let mut result__: <VarArgsKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<VarArgsKind>(result__)
}
pub unsafe fn GetFunctionInstancePointerType(&self) -> ::windows::core::Result<IDebugHostType2> {
let mut result__: <IDebugHostType2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType2>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostType2 {
type Vtable = IDebugHostType2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb28632b9_8506_4676_87ce_8f7e05e59876);
}
impl ::core::convert::From<IDebugHostType2> for ::windows::core::IUnknown {
fn from(value: IDebugHostType2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostType2> for ::windows::core::IUnknown {
fn from(value: &IDebugHostType2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugHostType2> for IDebugHostType {
fn from(value: IDebugHostType2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostType2> for IDebugHostType {
fn from(value: &IDebugHostType2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostType> for IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostType> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostType> for &IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostType> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IDebugHostType2> for IDebugHostSymbol {
fn from(value: IDebugHostType2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugHostType2> for IDebugHostSymbol {
fn from(value: &IDebugHostType2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugHostSymbol> for &IDebugHostType2 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugHostSymbol> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostType2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut SymbolKind) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingmodule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcomparisonsymbol: ::windows::core::RawPtr, comparisonflags: u32, pmatches: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut TypeKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, size: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, basetype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hashcode: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, intrinsickind: *mut IntrinsicKind, carriertype: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lsboffield: *mut u32, lengthoffield: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pointerkind: *mut PointerKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, membertype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: PointerKind, newtype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, arraydimensionality: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dimensions: u64, pdimensions: *mut ArrayDimension) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dimensions: u64, pdimensions: *const ArrayDimension, newtype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, conventionkind: *mut CallingConventionKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, returntype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, i: u64, parametertype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isgeneric: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, argcount: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, i: u64, argument: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, istypedef: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, basetype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, finalbasetype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, varargskind: *mut VarArgsKind) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instancepointertype: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugHostTypeSignature(pub ::windows::core::IUnknown);
impl IDebugHostTypeSignature {
pub unsafe fn GetHashCode(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn IsMatch<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostType>>(&self, r#type: Param0, ismatch: *mut bool, wildcardmatches: *mut ::core::option::Option<IDebugHostSymbolEnumerator>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), r#type.into_param().abi(), ::core::mem::transmute(ismatch), ::core::mem::transmute(wildcardmatches)).ok()
}
pub unsafe fn CompareAgainst<'a, Param0: ::windows::core::IntoParam<'a, IDebugHostTypeSignature>>(&self, typesignature: Param0) -> ::windows::core::Result<SignatureComparison> {
let mut result__: <SignatureComparison as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), typesignature.into_param().abi(), &mut result__).from_abi::<SignatureComparison>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugHostTypeSignature {
type Vtable = IDebugHostTypeSignature_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3aadc353_2b14_4abb_9893_5e03458e07ee);
}
impl ::core::convert::From<IDebugHostTypeSignature> for ::windows::core::IUnknown {
fn from(value: IDebugHostTypeSignature) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugHostTypeSignature> for ::windows::core::IUnknown {
fn from(value: &IDebugHostTypeSignature) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugHostTypeSignature {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugHostTypeSignature {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugHostTypeSignature_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hashcode: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::windows::core::RawPtr, ismatch: *mut bool, wildcardmatches: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typesignature: ::windows::core::RawPtr, result: *mut SignatureComparison) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugInputCallbacks(pub ::windows::core::IUnknown);
impl IDebugInputCallbacks {
pub unsafe fn StartInput(&self, buffersize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffersize)).ok()
}
pub unsafe fn EndInput(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugInputCallbacks {
type Vtable = IDebugInputCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9f50e42c_f136_499e_9a97_73036c94ed2d);
}
impl ::core::convert::From<IDebugInputCallbacks> for ::windows::core::IUnknown {
fn from(value: IDebugInputCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugInputCallbacks> for ::windows::core::IUnknown {
fn from(value: &IDebugInputCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugInputCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugInputCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugInputCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffersize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugOutputCallbacks(pub ::windows::core::IUnknown);
impl IDebugOutputCallbacks {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, text: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), text.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugOutputCallbacks {
type Vtable = IDebugOutputCallbacks_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4bf58045_d654_4c40_b0af_683090f356dc);
}
impl ::core::convert::From<IDebugOutputCallbacks> for ::windows::core::IUnknown {
fn from(value: IDebugOutputCallbacks) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugOutputCallbacks> for ::windows::core::IUnknown {
fn from(value: &IDebugOutputCallbacks) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugOutputCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugOutputCallbacks {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugOutputCallbacks_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, text: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugOutputCallbacks2(pub ::windows::core::IUnknown);
impl IDebugOutputCallbacks2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, mask: u32, text: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), text.into_param().abi()).ok()
}
pub unsafe fn GetInterestMask(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output2<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, which: u32, flags: u32, arg: u64, text: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(flags), ::core::mem::transmute(arg), text.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugOutputCallbacks2 {
type Vtable = IDebugOutputCallbacks2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x67721fe9_56d2_4a44_a325_2b65513ce6eb);
}
impl ::core::convert::From<IDebugOutputCallbacks2> for ::windows::core::IUnknown {
fn from(value: IDebugOutputCallbacks2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugOutputCallbacks2> for ::windows::core::IUnknown {
fn from(value: &IDebugOutputCallbacks2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugOutputCallbacks2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugOutputCallbacks2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugOutputCallbacks2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, text: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, flags: u32, arg: u64, text: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugOutputCallbacksWide(pub ::windows::core::IUnknown);
impl IDebugOutputCallbacksWide {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Output<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, mask: u32, text: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), text.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugOutputCallbacksWide {
type Vtable = IDebugOutputCallbacksWide_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4c7fd663_c394_4e26_8ef1_34ad5ed3764c);
}
impl ::core::convert::From<IDebugOutputCallbacksWide> for ::windows::core::IUnknown {
fn from(value: IDebugOutputCallbacksWide) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugOutputCallbacksWide> for ::windows::core::IUnknown {
fn from(value: &IDebugOutputCallbacksWide) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugOutputCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugOutputCallbacksWide {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugOutputCallbacksWide_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: u32, text: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugOutputStream(pub ::windows::core::IUnknown);
impl IDebugOutputStream {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugOutputStream {
type Vtable = IDebugOutputStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7782d8f2_2b85_4059_ab88_28ceddca1c80);
}
impl ::core::convert::From<IDebugOutputStream> for ::windows::core::IUnknown {
fn from(value: IDebugOutputStream) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugOutputStream> for ::windows::core::IUnknown {
fn from(value: &IDebugOutputStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugOutputStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugOutputStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugOutputStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPlmClient(pub ::windows::core::IUnknown);
impl IDebugPlmClient {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchPlmPackageForDebugWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, timeout: u32, packagefullname: Param2, appname: Param3, arguments: Param4, processid: *mut u32, threadid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(timeout), packagefullname.into_param().abi(), appname.into_param().abi(), arguments.into_param().abi(), ::core::mem::transmute(processid), ::core::mem::transmute(threadid)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugPlmClient {
type Vtable = IDebugPlmClient_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa02b66c4_aea3_4234_a9f7_fe4c383d4e29);
}
impl ::core::convert::From<IDebugPlmClient> for ::windows::core::IUnknown {
fn from(value: IDebugPlmClient) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPlmClient> for ::windows::core::IUnknown {
fn from(value: &IDebugPlmClient) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPlmClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPlmClient {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPlmClient_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, timeout: u32, packagefullname: super::super::super::Foundation::PWSTR, appname: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR, processid: *mut u32, threadid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPlmClient2(pub ::windows::core::IUnknown);
impl IDebugPlmClient2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchPlmPackageForDebugWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, timeout: u32, packagefullname: Param2, appname: Param3, arguments: Param4, processid: *mut u32, threadid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(timeout), packagefullname.into_param().abi(), appname.into_param().abi(), arguments.into_param().abi(), ::core::mem::transmute(processid), ::core::mem::transmute(threadid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchPlmBgTaskForDebugWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, timeout: u32, packagefullname: Param2, backgroundtaskid: Param3, processid: *mut u32, threadid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(timeout), packagefullname.into_param().abi(), backgroundtaskid.into_param().abi(), ::core::mem::transmute(processid), ::core::mem::transmute(threadid)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugPlmClient2 {
type Vtable = IDebugPlmClient2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x597c980d_e7bd_4309_962c_9d9b69a7372c);
}
impl ::core::convert::From<IDebugPlmClient2> for ::windows::core::IUnknown {
fn from(value: IDebugPlmClient2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPlmClient2> for ::windows::core::IUnknown {
fn from(value: &IDebugPlmClient2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPlmClient2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPlmClient2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPlmClient2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, timeout: u32, packagefullname: super::super::super::Foundation::PWSTR, appname: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR, processid: *mut u32, threadid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, timeout: u32, packagefullname: super::super::super::Foundation::PWSTR, backgroundtaskid: super::super::super::Foundation::PWSTR, processid: *mut u32, threadid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPlmClient3(pub ::windows::core::IUnknown);
impl IDebugPlmClient3 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchPlmPackageForDebugWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, timeout: u32, packagefullname: Param2, appname: Param3, arguments: Param4, processid: *mut u32, threadid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(timeout), packagefullname.into_param().abi(), appname.into_param().abi(), arguments.into_param().abi(), ::core::mem::transmute(processid), ::core::mem::transmute(threadid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchPlmBgTaskForDebugWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, timeout: u32, packagefullname: Param2, backgroundtaskid: Param3, processid: *mut u32, threadid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), ::core::mem::transmute(timeout), packagefullname.into_param().abi(), backgroundtaskid.into_param().abi(), ::core::mem::transmute(processid), ::core::mem::transmute(threadid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn QueryPlmPackageWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IDebugOutputStream>>(&self, server: u64, packagefullname: Param1, stream: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi(), stream.into_param().abi()).ok()
}
pub unsafe fn QueryPlmPackageList<'a, Param1: ::windows::core::IntoParam<'a, IDebugOutputStream>>(&self, server: u64, stream: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), stream.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnablePlmPackageDebugWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisablePlmPackageDebugWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SuspendPlmPackageWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ResumePlmPackageWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn TerminatePlmPackageWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LaunchAndDebugPlmAppWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1, appname: Param2, arguments: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi(), appname.into_param().abi(), arguments.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ActivateAndDebugPlmBgTaskWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, server: u64, packagefullname: Param1, backgroundtaskid: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), packagefullname.into_param().abi(), backgroundtaskid.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugPlmClient3 {
type Vtable = IDebugPlmClient3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd4a5dbd1_ca02_4d90_856a_2a92bfd0f20f);
}
impl ::core::convert::From<IDebugPlmClient3> for ::windows::core::IUnknown {
fn from(value: IDebugPlmClient3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPlmClient3> for ::windows::core::IUnknown {
fn from(value: &IDebugPlmClient3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPlmClient3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPlmClient3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPlmClient3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, timeout: u32, packagefullname: super::super::super::Foundation::PWSTR, appname: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR, processid: *mut u32, threadid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, timeout: u32, packagefullname: super::super::super::Foundation::PWSTR, backgroundtaskid: super::super::super::Foundation::PWSTR, processid: *mut u32, threadid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR, stream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, stream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR, appname: super::super::super::Foundation::PWSTR, arguments: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, packagefullname: super::super::super::Foundation::PWSTR, backgroundtaskid: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugProperty(pub ::windows::core::IUnknown);
impl IDebugProperty {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyInfo(&self, dwfieldspec: u32, nradix: u32) -> ::windows::core::Result<DebugPropertyInfo> {
let mut result__: <DebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), &mut result__).from_abi::<DebugPropertyInfo>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetExtendedInfo(&self, cinfos: u32, rgguidextendedinfo: *const ::windows::core::GUID, rgvar: *mut super::super::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(cinfos), ::core::mem::transmute(rgguidextendedinfo), ::core::mem::transmute(rgvar)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValueAsString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pszvalue: Param0, nradix: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvalue.into_param().abi(), ::core::mem::transmute(nradix)).ok()
}
pub unsafe fn EnumMembers(&self, dwfieldspec: u32, nradix: u32, refiid: *const ::windows::core::GUID) -> ::windows::core::Result<IEnumDebugPropertyInfo> {
let mut result__: <IEnumDebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwfieldspec), ::core::mem::transmute(nradix), ::core::mem::transmute(refiid), &mut result__).from_abi::<IEnumDebugPropertyInfo>(result__)
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugProperty>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugProperty {
type Vtable = IDebugProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c50_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugProperty> for ::windows::core::IUnknown {
fn from(value: IDebugProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugProperty> for ::windows::core::IUnknown {
fn from(value: &IDebugProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, ppropertyinfo: *mut ::core::mem::ManuallyDrop<DebugPropertyInfo>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cinfos: u32, rgguidextendedinfo: *const ::windows::core::GUID, rgvar: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvalue: super::super::super::Foundation::PWSTR, nradix: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwfieldspec: u32, nradix: u32, refiid: *const ::windows::core::GUID, ppepi: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdebugprop: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPropertyEnumType_All(pub ::windows::core::IUnknown);
impl IDebugPropertyEnumType_All {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugPropertyEnumType_All {
type Vtable = IDebugPropertyEnumType_All_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c55_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugPropertyEnumType_All> for ::windows::core::IUnknown {
fn from(value: IDebugPropertyEnumType_All) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_All> for ::windows::core::IUnknown {
fn from(value: &IDebugPropertyEnumType_All) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPropertyEnumType_All {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPropertyEnumType_All {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPropertyEnumType_All_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__idebugpropertyenumtype_all0000: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPropertyEnumType_Arguments(pub ::windows::core::IUnknown);
impl IDebugPropertyEnumType_Arguments {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugPropertyEnumType_Arguments {
type Vtable = IDebugPropertyEnumType_Arguments_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c57_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugPropertyEnumType_Arguments> for ::windows::core::IUnknown {
fn from(value: IDebugPropertyEnumType_Arguments) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Arguments> for ::windows::core::IUnknown {
fn from(value: &IDebugPropertyEnumType_Arguments) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPropertyEnumType_Arguments {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPropertyEnumType_Arguments {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugPropertyEnumType_Arguments> for IDebugPropertyEnumType_All {
fn from(value: IDebugPropertyEnumType_Arguments) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Arguments> for IDebugPropertyEnumType_All {
fn from(value: &IDebugPropertyEnumType_Arguments) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for IDebugPropertyEnumType_Arguments {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for &IDebugPropertyEnumType_Arguments {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPropertyEnumType_Arguments_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__idebugpropertyenumtype_all0000: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPropertyEnumType_Locals(pub ::windows::core::IUnknown);
impl IDebugPropertyEnumType_Locals {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugPropertyEnumType_Locals {
type Vtable = IDebugPropertyEnumType_Locals_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c56_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugPropertyEnumType_Locals> for ::windows::core::IUnknown {
fn from(value: IDebugPropertyEnumType_Locals) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Locals> for ::windows::core::IUnknown {
fn from(value: &IDebugPropertyEnumType_Locals) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPropertyEnumType_Locals {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPropertyEnumType_Locals {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugPropertyEnumType_Locals> for IDebugPropertyEnumType_All {
fn from(value: IDebugPropertyEnumType_Locals) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Locals> for IDebugPropertyEnumType_All {
fn from(value: &IDebugPropertyEnumType_Locals) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for IDebugPropertyEnumType_Locals {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for &IDebugPropertyEnumType_Locals {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPropertyEnumType_Locals_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__idebugpropertyenumtype_all0000: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPropertyEnumType_LocalsPlusArgs(pub ::windows::core::IUnknown);
impl IDebugPropertyEnumType_LocalsPlusArgs {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugPropertyEnumType_LocalsPlusArgs {
type Vtable = IDebugPropertyEnumType_LocalsPlusArgs_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c58_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugPropertyEnumType_LocalsPlusArgs> for ::windows::core::IUnknown {
fn from(value: IDebugPropertyEnumType_LocalsPlusArgs) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_LocalsPlusArgs> for ::windows::core::IUnknown {
fn from(value: &IDebugPropertyEnumType_LocalsPlusArgs) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPropertyEnumType_LocalsPlusArgs {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPropertyEnumType_LocalsPlusArgs {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugPropertyEnumType_LocalsPlusArgs> for IDebugPropertyEnumType_All {
fn from(value: IDebugPropertyEnumType_LocalsPlusArgs) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_LocalsPlusArgs> for IDebugPropertyEnumType_All {
fn from(value: &IDebugPropertyEnumType_LocalsPlusArgs) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for IDebugPropertyEnumType_LocalsPlusArgs {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for &IDebugPropertyEnumType_LocalsPlusArgs {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPropertyEnumType_LocalsPlusArgs_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__idebugpropertyenumtype_all0000: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugPropertyEnumType_Registers(pub ::windows::core::IUnknown);
impl IDebugPropertyEnumType_Registers {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugPropertyEnumType_Registers {
type Vtable = IDebugPropertyEnumType_Registers_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c59_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugPropertyEnumType_Registers> for ::windows::core::IUnknown {
fn from(value: IDebugPropertyEnumType_Registers) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Registers> for ::windows::core::IUnknown {
fn from(value: &IDebugPropertyEnumType_Registers) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugPropertyEnumType_Registers {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugPropertyEnumType_Registers {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugPropertyEnumType_Registers> for IDebugPropertyEnumType_All {
fn from(value: IDebugPropertyEnumType_Registers) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugPropertyEnumType_Registers> for IDebugPropertyEnumType_All {
fn from(value: &IDebugPropertyEnumType_Registers) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for IDebugPropertyEnumType_Registers {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugPropertyEnumType_All> for &IDebugPropertyEnumType_Registers {
fn into_param(self) -> ::windows::core::Param<'a, IDebugPropertyEnumType_All> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugPropertyEnumType_Registers_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, __midl__idebugpropertyenumtype_all0000: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugRegisters(pub ::windows::core::IUnknown);
impl IDebugRegisters {
pub unsafe fn GetNumberRegisters(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(desc)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIndexByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValue(&self, register: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValue(&self, register: u32, value: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(value)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValues(&self, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValues(&self, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
pub unsafe fn OutputRegisters(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInstructionOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetStackOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetFrameOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugRegisters {
type Vtable = IDebugRegisters_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xce289126_9e84_45a7_937e_67bb18691493);
}
impl ::core::convert::From<IDebugRegisters> for ::windows::core::IUnknown {
fn from(value: IDebugRegisters) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugRegisters> for ::windows::core::IUnknown {
fn from(value: &IDebugRegisters) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugRegisters {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugRegisters {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugRegisters_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, value: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, value: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugRegisters2(pub ::windows::core::IUnknown);
impl IDebugRegisters2 {
pub unsafe fn GetNumberRegisters(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(desc)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIndexByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValue(&self, register: u32) -> ::windows::core::Result<DEBUG_VALUE> {
let mut result__: <DEBUG_VALUE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), &mut result__).from_abi::<DEBUG_VALUE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValue(&self, register: u32, value: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(value)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValues(&self, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValues(&self, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
pub unsafe fn OutputRegisters(&self, outputcontrol: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInstructionOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetStackOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetFrameOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescriptionWide(&self, register: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(desc)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIndexByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberPseudoRegisters(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPseudoDescription(&self, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, typemodule: *mut u64, typeid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(typemodule), ::core::mem::transmute(typeid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPseudoDescriptionWide(&self, register: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, typemodule: *mut u64, typeid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(register), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(typemodule), ::core::mem::transmute(typeid)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPseudoIndexByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPseudoIndexByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPseudoValues(&self, source: u32, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPseudoValues(&self, source: u32, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValues2(&self, source: u32, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValues2(&self, source: u32, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), ::core::mem::transmute(count), ::core::mem::transmute(indices), ::core::mem::transmute(start), ::core::mem::transmute(values)).ok()
}
pub unsafe fn OutputRegisters2(&self, outputcontrol: u32, source: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(source), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn GetInstructionOffset2(&self, source: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetStackOffset2(&self, source: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetFrameOffset2(&self, source: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(source), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugRegisters2 {
type Vtable = IDebugRegisters2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1656afa9_19c6_4e3a_97e7_5dc9160cf9c4);
}
impl ::core::convert::From<IDebugRegisters2> for ::windows::core::IUnknown {
fn from(value: IDebugRegisters2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugRegisters2> for ::windows::core::IUnknown {
fn from(value: &IDebugRegisters2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugRegisters2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugRegisters2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugRegisters2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, value: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, value: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, desc: *mut DEBUG_REGISTER_DESCRIPTION) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, typemodule: *mut u64, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, register: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, typemodule: *mut u64, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, count: u32, indices: *const u32, start: u32, values: *mut DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, count: u32, indices: *const u32, start: u32, values: *const DEBUG_VALUE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, source: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, source: u32, offset: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSessionProvider(pub ::windows::core::IUnknown);
impl IDebugSessionProvider {
pub unsafe fn StartDebugSession<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplication>>(&self, pda: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSessionProvider {
type Vtable = IDebugSessionProvider_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c29_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugSessionProvider> for ::windows::core::IUnknown {
fn from(value: IDebugSessionProvider) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSessionProvider> for ::windows::core::IUnknown {
fn from(value: &IDebugSessionProvider) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSessionProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSessionProvider {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSessionProvider_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugStackFrame(pub ::windows::core::IUnknown);
impl IDebugStackFrame {
pub unsafe fn GetCodeContext(&self) -> ::windows::core::Result<IDebugCodeContext> {
let mut result__: <IDebugCodeContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugCodeContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescriptionString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, flong: Param0) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), flong.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguageString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, flong: Param0) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), flong.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetThread(&self) -> ::windows::core::Result<IDebugApplicationThread> {
let mut result__: <IDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationThread>(result__)
}
pub unsafe fn GetDebugProperty(&self) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugProperty>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugStackFrame {
type Vtable = IDebugStackFrame_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c17_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugStackFrame> for ::windows::core::IUnknown {
fn from(value: IDebugStackFrame) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugStackFrame> for ::windows::core::IUnknown {
fn from(value: &IDebugStackFrame) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugStackFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugStackFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugStackFrame_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flong: super::super::super::Foundation::BOOL, pbstrdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flong: super::super::super::Foundation::BOOL, pbstrlanguage: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdebugprop: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugStackFrame110(pub ::windows::core::IUnknown);
impl IDebugStackFrame110 {
pub unsafe fn GetCodeContext(&self) -> ::windows::core::Result<IDebugCodeContext> {
let mut result__: <IDebugCodeContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugCodeContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescriptionString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, flong: Param0) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), flong.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguageString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, flong: Param0) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), flong.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetThread(&self) -> ::windows::core::Result<IDebugApplicationThread> {
let mut result__: <IDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationThread>(result__)
}
pub unsafe fn GetDebugProperty(&self) -> ::windows::core::Result<IDebugProperty> {
let mut result__: <IDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugProperty>(result__)
}
pub unsafe fn GetStackFrameType(&self) -> ::windows::core::Result<DEBUG_STACKFRAME_TYPE> {
let mut result__: <DEBUG_STACKFRAME_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<DEBUG_STACKFRAME_TYPE>(result__)
}
pub unsafe fn GetScriptInvocationContext(&self) -> ::windows::core::Result<IScriptInvocationContext> {
let mut result__: <IScriptInvocationContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IScriptInvocationContext>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugStackFrame110 {
type Vtable = IDebugStackFrame110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4b509611_b6ea_4b24_adcb_d0ccfd1a7e33);
}
impl ::core::convert::From<IDebugStackFrame110> for ::windows::core::IUnknown {
fn from(value: IDebugStackFrame110) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugStackFrame110> for ::windows::core::IUnknown {
fn from(value: &IDebugStackFrame110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugStackFrame110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugStackFrame110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugStackFrame110> for IDebugStackFrame {
fn from(value: IDebugStackFrame110) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugStackFrame110> for IDebugStackFrame {
fn from(value: &IDebugStackFrame110) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrame> for IDebugStackFrame110 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrame> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrame> for &IDebugStackFrame110 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrame> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugStackFrame110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flong: super::super::super::Foundation::BOOL, pbstrdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flong: super::super::super::Foundation::BOOL, pbstrlanguage: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdebugprop: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstackframekind: *mut DEBUG_STACKFRAME_TYPE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppinvocationcontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugStackFrameSniffer(pub ::windows::core::IUnknown);
impl IDebugStackFrameSniffer {
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugStackFrameSniffer {
type Vtable = IDebugStackFrameSniffer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c18_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugStackFrameSniffer> for ::windows::core::IUnknown {
fn from(value: IDebugStackFrameSniffer) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugStackFrameSniffer> for ::windows::core::IUnknown {
fn from(value: &IDebugStackFrameSniffer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugStackFrameSniffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugStackFrameSniffer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugStackFrameSniffer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugStackFrameSnifferEx32(pub ::windows::core::IUnknown);
impl IDebugStackFrameSnifferEx32 {
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
pub unsafe fn EnumStackFramesEx32(&self, dwspmin: u32) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwspmin), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugStackFrameSnifferEx32 {
type Vtable = IDebugStackFrameSnifferEx32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c19_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugStackFrameSnifferEx32> for ::windows::core::IUnknown {
fn from(value: IDebugStackFrameSnifferEx32) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugStackFrameSnifferEx32> for ::windows::core::IUnknown {
fn from(value: &IDebugStackFrameSnifferEx32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugStackFrameSnifferEx32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugStackFrameSnifferEx32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugStackFrameSnifferEx32> for IDebugStackFrameSniffer {
fn from(value: IDebugStackFrameSnifferEx32) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugStackFrameSnifferEx32> for IDebugStackFrameSniffer {
fn from(value: &IDebugStackFrameSnifferEx32) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrameSniffer> for IDebugStackFrameSnifferEx32 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrameSniffer> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrameSniffer> for &IDebugStackFrameSnifferEx32 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrameSniffer> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugStackFrameSnifferEx32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwspmin: u32, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugStackFrameSnifferEx64(pub ::windows::core::IUnknown);
impl IDebugStackFrameSnifferEx64 {
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
pub unsafe fn EnumStackFramesEx64(&self, dwspmin: u64) -> ::windows::core::Result<IEnumDebugStackFrames64> {
let mut result__: <IEnumDebugStackFrames64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwspmin), &mut result__).from_abi::<IEnumDebugStackFrames64>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugStackFrameSnifferEx64 {
type Vtable = IDebugStackFrameSnifferEx64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8cd12af4_49c1_4d52_8d8a_c146f47581aa);
}
impl ::core::convert::From<IDebugStackFrameSnifferEx64> for ::windows::core::IUnknown {
fn from(value: IDebugStackFrameSnifferEx64) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugStackFrameSnifferEx64> for ::windows::core::IUnknown {
fn from(value: &IDebugStackFrameSnifferEx64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugStackFrameSnifferEx64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugStackFrameSnifferEx64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IDebugStackFrameSnifferEx64> for IDebugStackFrameSniffer {
fn from(value: IDebugStackFrameSnifferEx64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IDebugStackFrameSnifferEx64> for IDebugStackFrameSniffer {
fn from(value: &IDebugStackFrameSnifferEx64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrameSniffer> for IDebugStackFrameSnifferEx64 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrameSniffer> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IDebugStackFrameSniffer> for &IDebugStackFrameSnifferEx64 {
fn into_param(self) -> ::windows::core::Param<'a, IDebugStackFrameSniffer> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugStackFrameSnifferEx64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwspmin: u64, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbolGroup(pub ::windows::core::IUnknown);
impl IDebugSymbolGroup {
pub unsafe fn GetNumberSymbols(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSymbol<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, index: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(index)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveSymbolByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn RemoveSymbolByIndex(&self, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolName(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetSymbolParameters(&self, start: u32, count: u32, params: *mut DEBUG_SYMBOL_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExpandSymbol<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, index: u32, expand: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), expand.into_param().abi()).ok()
}
pub unsafe fn OutputSymbols(&self, outputcontrol: u32, flags: u32, start: u32, count: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(start), ::core::mem::transmute(count)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteSymbol<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, value: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), value.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputAsType<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, r#type: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), r#type.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSymbolGroup {
type Vtable = IDebugSymbolGroup_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2528316_0f1a_4431_aeed_11d096e1e2ab);
}
impl ::core::convert::From<IDebugSymbolGroup> for ::windows::core::IUnknown {
fn from(value: IDebugSymbolGroup) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbolGroup> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbolGroup) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbolGroup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbolGroup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbolGroup_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SYMBOL_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, expand: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, start: u32, count: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, value: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, r#type: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbolGroup2(pub ::windows::core::IUnknown);
impl IDebugSymbolGroup2 {
pub unsafe fn GetNumberSymbols(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSymbol<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, index: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(index)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveSymbolByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
pub unsafe fn RemoveSymbolByIndex(&self, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolName(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetSymbolParameters(&self, start: u32, count: u32, params: *mut DEBUG_SYMBOL_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ExpandSymbol<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, index: u32, expand: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), expand.into_param().abi()).ok()
}
pub unsafe fn OutputSymbols(&self, outputcontrol: u32, flags: u32, start: u32, count: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(start), ::core::mem::transmute(count)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteSymbol<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, value: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), value.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputAsType<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, r#type: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), r#type.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSymbolWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, index: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(index)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveSymbolByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolNameWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn WriteSymbolWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, value: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), value.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OutputAsTypeWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, r#type: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), r#type.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeName(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeNameWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetSymbolSize(&self, index: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSymbolOffset(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetSymbolRegister(&self, index: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolValueText(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolValueTextWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetSymbolEntryInformation(&self, index: u32) -> ::windows::core::Result<DEBUG_SYMBOL_ENTRY> {
let mut result__: <DEBUG_SYMBOL_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<DEBUG_SYMBOL_ENTRY>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugSymbolGroup2 {
type Vtable = IDebugSymbolGroup2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6a7ccc5f_fb5e_4dcc_b41c_6c20307bccc7);
}
impl ::core::convert::From<IDebugSymbolGroup2> for ::windows::core::IUnknown {
fn from(value: IDebugSymbolGroup2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbolGroup2> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbolGroup2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbolGroup2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbolGroup2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbolGroup2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, params: *mut DEBUG_SYMBOL_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, expand: super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, start: u32, count: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, value: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, r#type: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, index: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, value: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, r#type: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, size: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, register: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, entry: *mut DEBUG_SYMBOL_ENTRY) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbols(pub ::windows::core::IUnknown);
impl IDebugSymbols {
pub unsafe fn GetSymbolOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffset(&self, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffset(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffset(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNumberModules(&self, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(loaded), ::core::mem::transmute(unloaded)).ok()
}
pub unsafe fn GetModuleByIndex(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset(&self, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNames(&self, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(base),
::core::mem::transmute(imagenamebuffer),
::core::mem::transmute(imagenamebuffersize),
::core::mem::transmute(imagenamesize),
::core::mem::transmute(modulenamebuffer),
::core::mem::transmute(modulenamebuffersize),
::core::mem::transmute(modulenamesize),
::core::mem::transmute(loadedimagenamebuffer),
::core::mem::transmute(loadedimagenamebuffersize),
::core::mem::transmute(loadedimagenamesize),
)
.ok()
}
pub unsafe fn GetModuleParameters(&self, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(bases), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeName(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeId<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTypeSize(&self, module: u64, typeid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeId<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetOffsetTypeId(&self, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn ReadTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataVirtual(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn ReadTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataPhysical(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScope(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScope(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
pub unsafe fn ResetScope(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScopeSymbolGroup<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
pub unsafe fn CreateSymbolGroup(&self) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatch(&self, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn EndSymbolMatch(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Reload<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElement(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsets<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSymbols {
type Vtable = IDebugSymbols_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8c31e98c_983a_48a5_9016_6fe5d667a950);
}
impl ::core::convert::From<IDebugSymbols> for ::windows::core::IUnknown {
fn from(value: IDebugSymbols) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbols> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbols) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbols {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbols {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbols_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, size: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbols2(pub ::windows::core::IUnknown);
impl IDebugSymbols2 {
pub unsafe fn GetSymbolOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffset(&self, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffset(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffset(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNumberModules(&self, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(loaded), ::core::mem::transmute(unloaded)).ok()
}
pub unsafe fn GetModuleByIndex(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset(&self, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNames(&self, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(base),
::core::mem::transmute(imagenamebuffer),
::core::mem::transmute(imagenamebuffersize),
::core::mem::transmute(imagenamesize),
::core::mem::transmute(modulenamebuffer),
::core::mem::transmute(modulenamebuffersize),
::core::mem::transmute(modulenamesize),
::core::mem::transmute(loadedimagenamebuffer),
::core::mem::transmute(loadedimagenamebuffersize),
::core::mem::transmute(loadedimagenamesize),
)
.ok()
}
pub unsafe fn GetModuleParameters(&self, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(bases), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeName(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeId<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTypeSize(&self, module: u64, typeid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeId<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetOffsetTypeId(&self, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn ReadTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataVirtual(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn ReadTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataPhysical(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScope(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScope(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
pub unsafe fn ResetScope(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScopeSymbolGroup<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
pub unsafe fn CreateSymbolGroup(&self) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatch(&self, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn EndSymbolMatch(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Reload<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElement(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsets<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformation<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameString(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantName(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldName(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetTypeOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSymbols2 {
type Vtable = IDebugSymbols2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3a707211_afdd_4495_ad4f_56fecdf8163f);
}
impl ::core::convert::From<IDebugSymbols2> for ::windows::core::IUnknown {
fn from(value: IDebugSymbols2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbols2> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbols2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbols2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbols2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbols2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, size: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbols3(pub ::windows::core::IUnknown);
impl IDebugSymbols3 {
pub unsafe fn GetSymbolOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffset(&self, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffset(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffset(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNumberModules(&self, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(loaded), ::core::mem::transmute(unloaded)).ok()
}
pub unsafe fn GetModuleByIndex(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset(&self, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNames(&self, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(base),
::core::mem::transmute(imagenamebuffer),
::core::mem::transmute(imagenamebuffersize),
::core::mem::transmute(imagenamesize),
::core::mem::transmute(modulenamebuffer),
::core::mem::transmute(modulenamebuffersize),
::core::mem::transmute(modulenamesize),
::core::mem::transmute(loadedimagenamebuffer),
::core::mem::transmute(loadedimagenamebuffersize),
::core::mem::transmute(loadedimagenamesize),
)
.ok()
}
pub unsafe fn GetModuleParameters(&self, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(bases), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeName(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeId<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTypeSize(&self, module: u64, typeid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeId<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetOffsetTypeId(&self, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn ReadTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataVirtual(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn ReadTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataPhysical(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScope(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScope(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
pub unsafe fn ResetScope(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScopeSymbolGroup<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
pub unsafe fn CreateSymbolGroup(&self) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatch(&self, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn EndSymbolMatch(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Reload<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElement(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsets<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformation<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameString(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantName(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldName(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetTypeOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffsetWide(&self, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffsetWide(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffsetWide(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModuleWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeNameWide(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeIdWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeIdWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetScopeSymbolGroup2<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup2>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
pub unsafe fn CreateSymbolGroup2(&self) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatchWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatchWide(&self, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReloadWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElementWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsetsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformationWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameStringWide(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantNameWide(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldNameWide(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn IsManagedModule(&self, index: u32, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset2(&self, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModule<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModuleWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveSyntheticModule(&self, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetCurrentScopeFrameIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).99)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetScopeFrameByIndex(&self, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)).ok()
}
pub unsafe fn SetScopeFromJitDebugInfo(&self, outputcontrol: u32, infooffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(infooffset)).ok()
}
pub unsafe fn SetScopeFromStoredEvent(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputSymbolByOffset(&self, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetFunctionEntryByOffset(&self, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bufferneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbol<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbolWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn RemoveSyntheticSymbol(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetSymbolEntriesByOffset(&self, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(displacements), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
pub unsafe fn GetSymbolEntryByToken(&self, modulebase: u64, token: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(modulebase), ::core::mem::transmute(token), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSymbolEntryInformation(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<DEBUG_SYMBOL_ENTRY> {
let mut result__: <DEBUG_SYMBOL_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<DEBUG_SYMBOL_ENTRY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryString(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryStringWide(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSymbolEntryOffsetRegions(&self, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSymbolEntryBySymbolEntry(&self, fromid: *const DEBUG_MODULE_AND_ID, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromid), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSourceEntriesByOffset(&self, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryString(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryStringWide(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSourceEntryOffsetRegions(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSourceEntryBySourceEntry(&self, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32) -> ::windows::core::Result<DEBUG_SYMBOL_SOURCE_ENTRY> {
let mut result__: <DEBUG_SYMBOL_SOURCE_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromentry), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_SYMBOL_SOURCE_ENTRY>(result__)
}
}
unsafe impl ::windows::core::Interface for IDebugSymbols3 {
type Vtable = IDebugSymbols3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf02fbecc_50ac_4f36_9ad9_c975e8f32ff8);
}
impl ::core::convert::From<IDebugSymbols3> for ::windows::core::IUnknown {
fn from(value: IDebugSymbols3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbols3> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbols3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbols3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbols3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbols3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, size: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PWSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PWSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PWSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PWSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PWSTR, modulename: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, infooffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PWSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PWSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modulebase: u64, token: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, info: *mut DEBUG_SYMBOL_ENTRY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromid: *const DEBUG_MODULE_AND_ID, flags: u32, toid: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, toentry: *mut DEBUG_SYMBOL_SOURCE_ENTRY) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbols4(pub ::windows::core::IUnknown);
impl IDebugSymbols4 {
pub unsafe fn GetSymbolOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffset(&self, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffset(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffset(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNumberModules(&self, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(loaded), ::core::mem::transmute(unloaded)).ok()
}
pub unsafe fn GetModuleByIndex(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset(&self, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNames(&self, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(base),
::core::mem::transmute(imagenamebuffer),
::core::mem::transmute(imagenamebuffersize),
::core::mem::transmute(imagenamesize),
::core::mem::transmute(modulenamebuffer),
::core::mem::transmute(modulenamebuffersize),
::core::mem::transmute(modulenamesize),
::core::mem::transmute(loadedimagenamebuffer),
::core::mem::transmute(loadedimagenamebuffersize),
::core::mem::transmute(loadedimagenamesize),
)
.ok()
}
pub unsafe fn GetModuleParameters(&self, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(bases), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeName(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeId<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTypeSize(&self, module: u64, typeid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeId<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetOffsetTypeId(&self, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn ReadTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataVirtual(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn ReadTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataPhysical(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScope(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScope(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
pub unsafe fn ResetScope(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScopeSymbolGroup<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
pub unsafe fn CreateSymbolGroup(&self) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatch(&self, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn EndSymbolMatch(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Reload<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElement(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsets<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformation<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameString(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantName(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldName(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetTypeOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffsetWide(&self, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffsetWide(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffsetWide(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModuleWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeNameWide(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeIdWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeIdWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetScopeSymbolGroup2<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup2>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
pub unsafe fn CreateSymbolGroup2(&self) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatchWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatchWide(&self, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReloadWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElementWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsetsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformationWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameStringWide(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantNameWide(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldNameWide(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn IsManagedModule(&self, index: u32, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset2(&self, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModule<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModuleWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveSyntheticModule(&self, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetCurrentScopeFrameIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).99)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetScopeFrameByIndex(&self, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)).ok()
}
pub unsafe fn SetScopeFromJitDebugInfo(&self, outputcontrol: u32, infooffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(infooffset)).ok()
}
pub unsafe fn SetScopeFromStoredEvent(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputSymbolByOffset(&self, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetFunctionEntryByOffset(&self, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bufferneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbol<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbolWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn RemoveSyntheticSymbol(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetSymbolEntriesByOffset(&self, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(displacements), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
pub unsafe fn GetSymbolEntryByToken(&self, modulebase: u64, token: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(modulebase), ::core::mem::transmute(token), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSymbolEntryInformation(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<DEBUG_SYMBOL_ENTRY> {
let mut result__: <DEBUG_SYMBOL_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<DEBUG_SYMBOL_ENTRY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryString(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryStringWide(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSymbolEntryOffsetRegions(&self, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSymbolEntryBySymbolEntry(&self, fromid: *const DEBUG_MODULE_AND_ID, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromid), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSourceEntriesByOffset(&self, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryString(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryStringWide(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSourceEntryOffsetRegions(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSourceEntryBySourceEntry(&self, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32) -> ::windows::core::Result<DEBUG_SYMBOL_SOURCE_ENTRY> {
let mut result__: <DEBUG_SYMBOL_SOURCE_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromentry), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_SYMBOL_SOURCE_ENTRY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScopeEx(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME_EX, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScopeEx(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME_EX, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByInlineContext(&self, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByInlineContextWide(&self, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByInlineContext(&self, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByInlineContextWide(&self, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
pub unsafe fn OutputSymbolByInlineContext(&self, outputcontrol: u32, flags: u32, offset: u64, inlinecontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSymbols4 {
type Vtable = IDebugSymbols4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe391bbd8_9d8c_4418_840b_c006592a1752);
}
impl ::core::convert::From<IDebugSymbols4> for ::windows::core::IUnknown {
fn from(value: IDebugSymbols4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbols4> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbols4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbols4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbols4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbols4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, size: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PWSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PWSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PWSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PWSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PWSTR, modulename: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, infooffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PWSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PWSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modulebase: u64, token: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, info: *mut DEBUG_SYMBOL_ENTRY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromid: *const DEBUG_MODULE_AND_ID, flags: u32, toid: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, toentry: *mut DEBUG_SYMBOL_SOURCE_ENTRY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME_EX, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME_EX, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, offset: u64, inlinecontext: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSymbols5(pub ::windows::core::IUnknown);
impl IDebugSymbols5 {
pub unsafe fn GetSymbolOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetSymbolOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffset(&self, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffset(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffset(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetNumberModules(&self, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(loaded), ::core::mem::transmute(unloaded)).ok()
}
pub unsafe fn GetModuleByIndex(&self, index: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset(&self, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNames(&self, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(
::core::mem::transmute_copy(self),
::core::mem::transmute(index),
::core::mem::transmute(base),
::core::mem::transmute(imagenamebuffer),
::core::mem::transmute(imagenamebuffersize),
::core::mem::transmute(imagenamesize),
::core::mem::transmute(modulenamebuffer),
::core::mem::transmute(modulenamebuffersize),
::core::mem::transmute(modulenamesize),
::core::mem::transmute(loadedimagenamebuffer),
::core::mem::transmute(loadedimagenamebuffersize),
::core::mem::transmute(loadedimagenamesize),
)
.ok()
}
pub unsafe fn GetModuleParameters(&self, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(bases), ::core::mem::transmute(start), ::core::mem::transmute(params)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeName(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeId<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTypeSize(&self, module: u64, typeid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeId<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetOffsetTypeId(&self, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn ReadTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataVirtual(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataVirtual(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn ReadTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bytesread)).ok()
}
pub unsafe fn WriteTypedDataPhysical(&self, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn OutputTypedDataPhysical(&self, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(offset), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScope(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScope(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
pub unsafe fn ResetScope(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetScopeSymbolGroup<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
pub unsafe fn CreateSymbolGroup(&self) -> ::windows::core::Result<IDebugSymbolGroup> {
let mut result__: <IDebugSymbolGroup as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatch(&self, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn EndSymbolMatch(&self, handle: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Reload<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePath(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElement(&self, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).48)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).49)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFile<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).50)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsets<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).51)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformation<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).52)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameString(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).53)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantName(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).54)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldName(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).55)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn GetTypeOptions(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).56)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn AddTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).57)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn RemoveTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).58)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
pub unsafe fn SetTypeOptions(&self, options: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).59)(::core::mem::transmute_copy(self), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByOffsetWide(&self, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).60)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).61)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNearNameByOffsetWide(&self, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).62)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(delta), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByOffsetWide(&self, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).63)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetOffsetByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).64)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).65)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolModuleWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).66)(::core::mem::transmute_copy(self), symbol.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeNameWide(&self, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).67)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTypeIdWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, name: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).68)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), name.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, typeid: u32, field: Param2) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).69)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), field.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolTypeIdWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, typeid: *mut u32, module: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).70)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(typeid), ::core::mem::transmute(module)).ok()
}
pub unsafe fn GetScopeSymbolGroup2<'a, Param1: ::windows::core::IntoParam<'a, IDebugSymbolGroup2>>(&self, flags: u32, update: Param1) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).71)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), update.into_param().abi(), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
pub unsafe fn CreateSymbolGroup2(&self) -> ::windows::core::Result<IDebugSymbolGroup2> {
let mut result__: <IDebugSymbolGroup2 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).72)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugSymbolGroup2>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn StartSymbolMatchWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pattern: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).73)(::core::mem::transmute_copy(self), pattern.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNextSymbolMatchWide(&self, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).74)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(matchsize), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReloadWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).75)(::core::mem::transmute_copy(self), module.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolPathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).76)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).77)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSymbolPathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).78)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetImagePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).79)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).80)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendImagePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).81)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).82)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(pathsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourcePathElementWide(&self, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).83)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(elementsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, path: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).84)(::core::mem::transmute_copy(self), path.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendSourcePathWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, addition: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).85)(::core::mem::transmute_copy(self), addition.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn FindSourceFileWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, startelement: u32, file: Param1, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).86)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(foundelement), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(foundsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceFileLineOffsetsWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, file: Param0, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).87)(::core::mem::transmute_copy(self), file.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines), ::core::mem::transmute(filelines)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleVersionInformationWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, index: u32, base: u64, item: Param2, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).88)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base), item.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(verinfosize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleNameStringWide(&self, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).89)(::core::mem::transmute_copy(self), ::core::mem::transmute(which), ::core::mem::transmute(index), ::core::mem::transmute(base), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetConstantNameWide(&self, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).90)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(value), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldNameWide(&self, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).91)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(typeid), ::core::mem::transmute(fieldindex), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize)).ok()
}
pub unsafe fn IsManagedModule(&self, index: u32, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).92)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).93)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetModuleByModuleName2Wide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, name: Param0, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).94)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetModuleByOffset2(&self, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).95)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(startindex), ::core::mem::transmute(flags), ::core::mem::transmute(index), ::core::mem::transmute(base)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModule<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).96)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticModuleWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, base: u64, size: u32, imagepath: Param2, modulename: Param3, flags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).97)(::core::mem::transmute_copy(self), ::core::mem::transmute(base), ::core::mem::transmute(size), imagepath.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(flags)).ok()
}
pub unsafe fn RemoveSyntheticModule(&self, base: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).98)(::core::mem::transmute_copy(self), ::core::mem::transmute(base)).ok()
}
pub unsafe fn GetCurrentScopeFrameIndex(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).99)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetScopeFrameByIndex(&self, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).100)(::core::mem::transmute_copy(self), ::core::mem::transmute(index)).ok()
}
pub unsafe fn SetScopeFromJitDebugInfo(&self, outputcontrol: u32, infooffset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).101)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(infooffset)).ok()
}
pub unsafe fn SetScopeFromStoredEvent(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).102)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OutputSymbolByOffset(&self, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).103)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetFunctionEntryByOffset(&self, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).104)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(bufferneeded)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffset<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).105)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetFieldTypeAndOffsetWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, module: u64, containertypeid: u32, field: Param2, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).106)(::core::mem::transmute_copy(self), ::core::mem::transmute(module), ::core::mem::transmute(containertypeid), field.into_param().abi(), ::core::mem::transmute(fieldtypeid), ::core::mem::transmute(offset)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbol<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).107)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddSyntheticSymbolWide<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, offset: u64, size: u32, name: Param2, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).108)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(size), name.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn RemoveSyntheticSymbol(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).109)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetSymbolEntriesByOffset(&self, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).110)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(displacements), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).111)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntriesByNameWide<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, symbol: Param0, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).112)(::core::mem::transmute_copy(self), symbol.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(ids), ::core::mem::transmute(idscount), ::core::mem::transmute(entries)).ok()
}
pub unsafe fn GetSymbolEntryByToken(&self, modulebase: u64, token: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).113)(::core::mem::transmute_copy(self), ::core::mem::transmute(modulebase), ::core::mem::transmute(token), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSymbolEntryInformation(&self, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::Result<DEBUG_SYMBOL_ENTRY> {
let mut result__: <DEBUG_SYMBOL_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).114)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), &mut result__).from_abi::<DEBUG_SYMBOL_ENTRY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryString(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).115)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSymbolEntryStringWide(&self, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).116)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSymbolEntryOffsetRegions(&self, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).117)(::core::mem::transmute_copy(self), ::core::mem::transmute(id), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSymbolEntryBySymbolEntry(&self, fromid: *const DEBUG_MODULE_AND_ID, flags: u32) -> ::windows::core::Result<DEBUG_MODULE_AND_ID> {
let mut result__: <DEBUG_MODULE_AND_ID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).118)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromid), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_MODULE_AND_ID>(result__)
}
pub unsafe fn GetSourceEntriesByOffset(&self, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).119)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLine<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).120)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntriesByLineWide<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, line: u32, file: Param1, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).121)(::core::mem::transmute_copy(self), ::core::mem::transmute(line), file.into_param().abi(), ::core::mem::transmute(flags), ::core::mem::transmute(entries), ::core::mem::transmute(entriescount), ::core::mem::transmute(entriesavail)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryString(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).122)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSourceEntryStringWide(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).123)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(which), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(stringsize)).ok()
}
pub unsafe fn GetSourceEntryOffsetRegions(&self, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).124)(::core::mem::transmute_copy(self), ::core::mem::transmute(entry), ::core::mem::transmute(flags), ::core::mem::transmute(regions), ::core::mem::transmute(regionscount), ::core::mem::transmute(regionsavail)).ok()
}
pub unsafe fn GetSourceEntryBySourceEntry(&self, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32) -> ::windows::core::Result<DEBUG_SYMBOL_SOURCE_ENTRY> {
let mut result__: <DEBUG_SYMBOL_SOURCE_ENTRY as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).125)(::core::mem::transmute_copy(self), ::core::mem::transmute(fromentry), ::core::mem::transmute(flags), &mut result__).from_abi::<DEBUG_SYMBOL_SOURCE_ENTRY>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetScopeEx(&self, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME_EX, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).126)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetScopeEx(&self, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME_EX, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).127)(::core::mem::transmute_copy(self), ::core::mem::transmute(instructionoffset), ::core::mem::transmute(scopeframe), ::core::mem::transmute(scopecontext), ::core::mem::transmute(scopecontextsize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByInlineContext(&self, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).128)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNameByInlineContextWide(&self, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).129)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(namebuffer), ::core::mem::transmute(namebuffersize), ::core::mem::transmute(namesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByInlineContext(&self, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).130)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLineByInlineContextWide(&self, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).131)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(line), ::core::mem::transmute(filebuffer), ::core::mem::transmute(filebuffersize), ::core::mem::transmute(filesize), ::core::mem::transmute(displacement)).ok()
}
pub unsafe fn OutputSymbolByInlineContext(&self, outputcontrol: u32, flags: u32, offset: u64, inlinecontext: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).132)(::core::mem::transmute_copy(self), ::core::mem::transmute(outputcontrol), ::core::mem::transmute(flags), ::core::mem::transmute(offset), ::core::mem::transmute(inlinecontext)).ok()
}
pub unsafe fn GetCurrentScopeFrameIndexEx(&self, flags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).133)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetScopeFrameByIndexEx(&self, flags: u32, index: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).134)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(index)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSymbols5 {
type Vtable = IDebugSymbols5_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc65fa83e_1e69_475e_8e0e_b5d79e9cc17e);
}
impl ::core::convert::From<IDebugSymbols5> for ::windows::core::IUnknown {
fn from(value: IDebugSymbols5) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSymbols5> for ::windows::core::IUnknown {
fn from(value: &IDebugSymbols5) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSymbols5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSymbols5 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSymbols5_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, loaded: *mut u32, unloaded: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, imagenamebuffer: super::super::super::Foundation::PSTR, imagenamebuffersize: u32, imagenamesize: *mut u32, modulenamebuffer: super::super::super::Foundation::PSTR, modulenamebuffersize: u32, modulenamesize: *mut u32, loadedimagenamebuffer: super::super::super::Foundation::PSTR, loadedimagenamebuffersize: u32, loadedimagenamesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, bases: *const u64, start: u32, params: *mut DEBUG_MODULE_PARAMETERS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, size: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, module: u64, typeid: u32, buffer: *const ::core::ffi::c_void, buffersize: u32, byteswritten: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, offset: u64, module: u64, typeid: u32, flags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, delta: i32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, name: super::super::super::Foundation::PWSTR, typeid: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, field: super::super::super::Foundation::PWSTR, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, typeid: *mut u32, module: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, update: ::windows::core::RawPtr, symbols: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, group: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pattern: super::super::super::Foundation::PWSTR, handle: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, matchsize: *mut u32, offset: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, pathsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, elementsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, path: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, addition: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: u32, file: super::super::super::Foundation::PWSTR, flags: u32, foundelement: *mut u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, foundsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, file: super::super::super::Foundation::PWSTR, buffer: *mut u64, bufferlines: u32, filelines: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64, item: super::super::super::Foundation::PWSTR, buffer: *mut ::core::ffi::c_void, buffersize: u32, verinfosize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, which: u32, index: u32, base: u64, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, value: u64, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, typeid: u32, fieldindex: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, base: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: super::super::super::Foundation::PWSTR, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, startindex: u32, flags: u32, index: *mut u32, base: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64, size: u32, imagepath: super::super::super::Foundation::PWSTR, modulename: super::super::super::Foundation::PWSTR, flags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, base: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, infooffset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, buffer: *mut ::core::ffi::c_void, buffersize: u32, bufferneeded: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, module: u64, containertypeid: u32, field: super::super::super::Foundation::PWSTR, fieldtypeid: *mut u32, offset: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, size: u32, name: super::super::super::Foundation::PWSTR, flags: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, displacements: *mut u64, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbol: super::super::super::Foundation::PWSTR, flags: u32, ids: *mut DEBUG_MODULE_AND_ID, idscount: u32, entries: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, modulebase: u64, token: u32, id: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, info: *mut DEBUG_SYMBOL_ENTRY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *const DEBUG_MODULE_AND_ID, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromid: *const DEBUG_MODULE_AND_ID, flags: u32, toid: *mut DEBUG_MODULE_AND_ID) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, line: u32, file: super::super::super::Foundation::PWSTR, flags: u32, entries: *mut DEBUG_SYMBOL_SOURCE_ENTRY, entriescount: u32, entriesavail: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, which: u32, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, stringsize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, entry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, regions: *mut DEBUG_OFFSET_REGION, regionscount: u32, regionsavail: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fromentry: *const DEBUG_SYMBOL_SOURCE_ENTRY, flags: u32, toentry: *mut DEBUG_SYMBOL_SOURCE_ENTRY) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: *mut u64, scopeframe: *mut DEBUG_STACK_FRAME_EX, scopecontext: *mut ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, instructionoffset: u64, scopeframe: *const DEBUG_STACK_FRAME_EX, scopecontext: *const ::core::ffi::c_void, scopecontextsize: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, namebuffer: super::super::super::Foundation::PWSTR, namebuffersize: u32, namesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, inlinecontext: u32, line: *mut u32, filebuffer: super::super::super::Foundation::PWSTR, filebuffersize: u32, filesize: *mut u32, displacement: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, outputcontrol: u32, flags: u32, offset: u64, inlinecontext: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, index: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: u32, index: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSyncOperation(pub ::windows::core::IUnknown);
impl IDebugSyncOperation {
pub unsafe fn GetTargetThread(&self) -> ::windows::core::Result<IDebugApplicationThread> {
let mut result__: <IDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationThread>(result__)
}
pub unsafe fn Execute(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn InProgressAbort(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSyncOperation {
type Vtable = IDebugSyncOperation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1a_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugSyncOperation> for ::windows::core::IUnknown {
fn from(value: IDebugSyncOperation) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSyncOperation> for ::windows::core::IUnknown {
fn from(value: &IDebugSyncOperation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSyncOperation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSyncOperation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSyncOperation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppattarget: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppunkresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSystemObjects(pub ::windows::core::IUnknown);
impl IDebugSystemObjects {
pub unsafe fn GetEventThread(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetEventProcess(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentThreadId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetCurrentProcessId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentProcessId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberThreads(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTotalNumberThreads(&self, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(total), ::core::mem::transmute(largestprocess)).ok()
}
pub unsafe fn GetThreadIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetThreadIdByProcessor(&self, processor: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadTeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByTeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetThreadIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberProcesses(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetCurrentProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessPeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByPeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProcessExecutableName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(exesize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSystemObjects {
type Vtable = IDebugSystemObjects_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6b86fe2c_2c4f_4f0c_9da2_174311acc327);
}
impl ::core::convert::From<IDebugSystemObjects> for ::windows::core::IUnknown {
fn from(value: IDebugSystemObjects) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSystemObjects> for ::windows::core::IUnknown {
fn from(value: &IDebugSystemObjects) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSystemObjects {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSystemObjects {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSystemObjects_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSystemObjects2(pub ::windows::core::IUnknown);
impl IDebugSystemObjects2 {
pub unsafe fn GetEventThread(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetEventProcess(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentThreadId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetCurrentProcessId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentProcessId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberThreads(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTotalNumberThreads(&self, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(total), ::core::mem::transmute(largestprocess)).ok()
}
pub unsafe fn GetThreadIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetThreadIdByProcessor(&self, processor: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadTeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByTeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetThreadIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberProcesses(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetCurrentProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessPeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByPeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProcessExecutableName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(exesize)).ok()
}
pub unsafe fn GetCurrentProcessUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetImplicitThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitThreadDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetImplicitProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitProcessDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSystemObjects2 {
type Vtable = IDebugSystemObjects2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0ae9f5ff_1852_4679_b055_494bee6407ee);
}
impl ::core::convert::From<IDebugSystemObjects2> for ::windows::core::IUnknown {
fn from(value: IDebugSystemObjects2) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSystemObjects2> for ::windows::core::IUnknown {
fn from(value: &IDebugSystemObjects2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSystemObjects2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSystemObjects2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSystemObjects2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSystemObjects3(pub ::windows::core::IUnknown);
impl IDebugSystemObjects3 {
pub unsafe fn GetEventThread(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetEventProcess(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentThreadId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetCurrentProcessId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentProcessId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberThreads(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTotalNumberThreads(&self, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(total), ::core::mem::transmute(largestprocess)).ok()
}
pub unsafe fn GetThreadIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetThreadIdByProcessor(&self, processor: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadTeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByTeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetThreadIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberProcesses(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetCurrentProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessPeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByPeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProcessExecutableName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(exesize)).ok()
}
pub unsafe fn GetCurrentProcessUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetImplicitThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitThreadDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetImplicitProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitProcessDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetEventSystem(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentSystemId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberSystems(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSystemIdsByIndex(&self, start: u32, count: u32, ids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids)).ok()
}
pub unsafe fn GetTotalNumberThreadsAndProcesses(&self, totalthreads: *mut u32, totalprocesses: *mut u32, largestprocessthreads: *mut u32, largestsystemthreads: *mut u32, largestsystemprocesses: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(totalthreads), ::core::mem::transmute(totalprocesses), ::core::mem::transmute(largestprocessthreads), ::core::mem::transmute(largestsystemthreads), ::core::mem::transmute(largestsystemprocesses)).ok()
}
pub unsafe fn GetCurrentSystemServer(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetSystemByServer(&self, server: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSystemServerName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSystemObjects3 {
type Vtable = IDebugSystemObjects3_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe9676e2f_e286_4ea3_b0f9_dfe5d9fc330e);
}
impl ::core::convert::From<IDebugSystemObjects3> for ::windows::core::IUnknown {
fn from(value: IDebugSystemObjects3) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSystemObjects3> for ::windows::core::IUnknown {
fn from(value: &IDebugSystemObjects3) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSystemObjects3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSystemObjects3 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSystemObjects3_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, totalthreads: *mut u32, totalprocesses: *mut u32, largestprocessthreads: *mut u32, largestsystemthreads: *mut u32, largestsystemprocesses: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugSystemObjects4(pub ::windows::core::IUnknown);
impl IDebugSystemObjects4 {
pub unsafe fn GetEventThread(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetEventProcess(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentThreadId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetCurrentProcessId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentProcessId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberThreads(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetTotalNumberThreads(&self, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(total), ::core::mem::transmute(largestprocess)).ok()
}
pub unsafe fn GetThreadIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetThreadIdByProcessor(&self, processor: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(processor), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadTeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByTeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetThreadIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentThreadHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetThreadIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberProcesses(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdsByIndex(&self, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids), ::core::mem::transmute(sysids)).ok()
}
pub unsafe fn GetCurrentProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByDataOffset(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessPeb(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByPeb(&self, offset: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetProcessIdBySystemId(&self, sysid: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(sysid), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentProcessHandle(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetProcessIdByHandle(&self, handle: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(handle), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProcessExecutableName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(exesize)).ok()
}
pub unsafe fn GetCurrentProcessUpTime(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetImplicitThreadDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitThreadDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetImplicitProcessDataOffset(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetImplicitProcessDataOffset(&self, offset: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), ::core::mem::transmute(offset)).ok()
}
pub unsafe fn GetEventSystem(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCurrentSystemId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn SetCurrentSystemId(&self, id: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).39)(::core::mem::transmute_copy(self), ::core::mem::transmute(id)).ok()
}
pub unsafe fn GetNumberSystems(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).40)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSystemIdsByIndex(&self, start: u32, count: u32, ids: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).41)(::core::mem::transmute_copy(self), ::core::mem::transmute(start), ::core::mem::transmute(count), ::core::mem::transmute(ids)).ok()
}
pub unsafe fn GetTotalNumberThreadsAndProcesses(&self, totalthreads: *mut u32, totalprocesses: *mut u32, largestprocessthreads: *mut u32, largestsystemthreads: *mut u32, largestsystemprocesses: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).42)(::core::mem::transmute_copy(self), ::core::mem::transmute(totalthreads), ::core::mem::transmute(totalprocesses), ::core::mem::transmute(largestprocessthreads), ::core::mem::transmute(largestsystemthreads), ::core::mem::transmute(largestsystemprocesses)).ok()
}
pub unsafe fn GetCurrentSystemServer(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).43)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetSystemByServer(&self, server: u64) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).44)(::core::mem::transmute_copy(self), ::core::mem::transmute(server), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSystemServerName(&self, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).45)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentProcessExecutableNameWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).46)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(exesize)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetCurrentSystemServerNameWide(&self, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).47)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(buffersize), ::core::mem::transmute(namesize)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugSystemObjects4 {
type Vtable = IDebugSystemObjects4_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x489468e6_7d0f_4af5_87ab_25207454d553);
}
impl ::core::convert::From<IDebugSystemObjects4> for ::windows::core::IUnknown {
fn from(value: IDebugSystemObjects4) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugSystemObjects4> for ::windows::core::IUnknown {
fn from(value: &IDebugSystemObjects4) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugSystemObjects4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugSystemObjects4 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugSystemObjects4_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, total: *mut u32, largestprocess: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processor: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32, sysids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, sysid: u32, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uptime: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offset: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, number: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, start: u32, count: u32, ids: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, totalthreads: *mut u32, totalprocesses: *mut u32, largestprocessthreads: *mut u32, largestsystemthreads: *mut u32, largestsystemprocesses: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, server: u64, id: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, exesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: super::super::super::Foundation::PWSTR, buffersize: u32, namesize: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugThreadCall32(pub ::windows::core::IUnknown);
impl IDebugThreadCall32 {
pub unsafe fn ThreadCallHandler(&self, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugThreadCall32 {
type Vtable = IDebugThreadCall32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c36_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IDebugThreadCall32> for ::windows::core::IUnknown {
fn from(value: IDebugThreadCall32) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugThreadCall32> for ::windows::core::IUnknown {
fn from(value: &IDebugThreadCall32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugThreadCall32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugThreadCall32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugThreadCall32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwparam1: u32, dwparam2: u32, dwparam3: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDebugThreadCall64(pub ::windows::core::IUnknown);
impl IDebugThreadCall64 {
pub unsafe fn ThreadCallHandler(&self, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwparam1), ::core::mem::transmute(dwparam2), ::core::mem::transmute(dwparam3)).ok()
}
}
unsafe impl ::windows::core::Interface for IDebugThreadCall64 {
type Vtable = IDebugThreadCall64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcb3fa335_e979_42fd_9fcf_a7546a0f3905);
}
impl ::core::convert::From<IDebugThreadCall64> for ::windows::core::IUnknown {
fn from(value: IDebugThreadCall64) -> Self {
value.0
}
}
impl ::core::convert::From<&IDebugThreadCall64> for ::windows::core::IUnknown {
fn from(value: &IDebugThreadCall64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDebugThreadCall64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDebugThreadCall64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDebugThreadCall64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwparam1: u64, dwparam2: u64, dwparam3: u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDynamicConceptProviderConcept(pub ::windows::core::IUnknown);
impl IDynamicConceptProviderConcept {
pub unsafe fn GetConcept<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0, conceptid: *const ::windows::core::GUID, conceptinterface: *mut ::core::option::Option<::windows::core::IUnknown>, conceptmetadata: *mut ::core::option::Option<IKeyStore>, hasconcept: *mut bool) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), ::core::mem::transmute(conceptid), ::core::mem::transmute(conceptinterface), ::core::mem::transmute(conceptmetadata), ::core::mem::transmute(hasconcept)).ok()
}
pub unsafe fn SetConcept<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param3: ::windows::core::IntoParam<'a, IKeyStore>>(&self, contextobject: Param0, conceptid: *const ::windows::core::GUID, conceptinterface: Param2, conceptmetadata: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), ::core::mem::transmute(conceptid), conceptinterface.into_param().abi(), conceptmetadata.into_param().abi()).ok()
}
pub unsafe fn NotifyParent<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, parentmodel: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), parentmodel.into_param().abi()).ok()
}
pub unsafe fn NotifyParentChange<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, parentmodel: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), parentmodel.into_param().abi()).ok()
}
pub unsafe fn NotifyDestruct(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IDynamicConceptProviderConcept {
type Vtable = IDynamicConceptProviderConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95a7f7dd_602e_483f_9d06_a15c0ee13174);
}
impl ::core::convert::From<IDynamicConceptProviderConcept> for ::windows::core::IUnknown {
fn from(value: IDynamicConceptProviderConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IDynamicConceptProviderConcept> for ::windows::core::IUnknown {
fn from(value: &IDynamicConceptProviderConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDynamicConceptProviderConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDynamicConceptProviderConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDynamicConceptProviderConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, conceptid: *const ::windows::core::GUID, conceptinterface: *mut ::windows::core::RawPtr, conceptmetadata: *mut ::windows::core::RawPtr, hasconcept: *mut bool) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, conceptid: *const ::windows::core::GUID, conceptinterface: ::windows::core::RawPtr, conceptmetadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parentmodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parentmodel: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IDynamicKeyProviderConcept(pub ::windows::core::IUnknown);
impl IDynamicKeyProviderConcept {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKey<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, contextobject: Param0, key: Param1, keyvalue: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>, haskey: *mut bool) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), key.into_param().abi(), ::core::mem::transmute(keyvalue), ::core::mem::transmute(metadata), ::core::mem::transmute(haskey)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, IModelObject>, Param3: ::windows::core::IntoParam<'a, IKeyStore>>(&self, contextobject: Param0, key: Param1, keyvalue: Param2, metadata: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), key.into_param().abi(), keyvalue.into_param().abi(), metadata.into_param().abi()).ok()
}
pub unsafe fn EnumerateKeys<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
}
unsafe impl ::windows::core::Interface for IDynamicKeyProviderConcept {
type Vtable = IDynamicKeyProviderConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe7983fa1_80a7_498c_988f_518ddc5d4025);
}
impl ::core::convert::From<IDynamicKeyProviderConcept> for ::windows::core::IUnknown {
fn from(value: IDynamicKeyProviderConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IDynamicKeyProviderConcept> for ::windows::core::IUnknown {
fn from(value: &IDynamicKeyProviderConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IDynamicKeyProviderConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IDynamicKeyProviderConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IDynamicKeyProviderConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, keyvalue: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr, haskey: *mut bool) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, keyvalue: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, ppenumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugApplicationNodes(pub ::windows::core::IUnknown);
impl IEnumDebugApplicationNodes {
pub unsafe fn Next(&self, celt: u32, pprddp: *mut ::core::option::Option<IDebugApplicationNode>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(pprddp), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugApplicationNodes> {
let mut result__: <IEnumDebugApplicationNodes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugApplicationNodes>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugApplicationNodes {
type Vtable = IEnumDebugApplicationNodes_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c3a_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugApplicationNodes> for ::windows::core::IUnknown {
fn from(value: IEnumDebugApplicationNodes) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugApplicationNodes> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugApplicationNodes) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugApplicationNodes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugApplicationNodes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugApplicationNodes_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, pprddp: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperddp: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugCodeContexts(pub ::windows::core::IUnknown);
impl IEnumDebugCodeContexts {
pub unsafe fn Next(&self, celt: u32, pscc: *mut ::core::option::Option<IDebugCodeContext>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(pscc), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugCodeContexts> {
let mut result__: <IEnumDebugCodeContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugCodeContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugCodeContexts {
type Vtable = IEnumDebugCodeContexts_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1d_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugCodeContexts> for ::windows::core::IUnknown {
fn from(value: IEnumDebugCodeContexts) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugCodeContexts> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugCodeContexts) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugCodeContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugCodeContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugCodeContexts_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, pscc: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppescc: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugExpressionContexts(pub ::windows::core::IUnknown);
impl IEnumDebugExpressionContexts {
pub unsafe fn Next(&self, celt: u32, ppdec: *mut ::core::option::Option<IDebugExpressionContext>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(ppdec), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugExpressionContexts> {
let mut result__: <IEnumDebugExpressionContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExpressionContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugExpressionContexts {
type Vtable = IEnumDebugExpressionContexts_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c40_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugExpressionContexts> for ::windows::core::IUnknown {
fn from(value: IEnumDebugExpressionContexts) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugExpressionContexts> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugExpressionContexts) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugExpressionContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugExpressionContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugExpressionContexts_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, ppdec: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedec: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugExtendedPropertyInfo(pub ::windows::core::IUnknown);
impl IEnumDebugExtendedPropertyInfo {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))]
pub unsafe fn Next(&self, celt: u32, rgextendedpropertyinfo: *mut ExtendedDebugPropertyInfo, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(rgextendedpropertyinfo), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugExtendedPropertyInfo> {
let mut result__: <IEnumDebugExtendedPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExtendedPropertyInfo>(result__)
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugExtendedPropertyInfo {
type Vtable = IEnumDebugExtendedPropertyInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c53_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugExtendedPropertyInfo> for ::windows::core::IUnknown {
fn from(value: IEnumDebugExtendedPropertyInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugExtendedPropertyInfo> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugExtendedPropertyInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugExtendedPropertyInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugExtendedPropertyInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugExtendedPropertyInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, rgextendedpropertyinfo: *mut ::core::mem::ManuallyDrop<ExtendedDebugPropertyInfo>, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Com_StructuredStorage", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pedpe: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcelt: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugPropertyInfo(pub ::windows::core::IUnknown);
impl IEnumDebugPropertyInfo {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Next(&self, celt: u32, pi: *mut DebugPropertyInfo, pceltsfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(pi), ::core::mem::transmute(pceltsfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugPropertyInfo> {
let mut result__: <IEnumDebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugPropertyInfo>(result__)
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugPropertyInfo {
type Vtable = IEnumDebugPropertyInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c51_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugPropertyInfo> for ::windows::core::IUnknown {
fn from(value: IEnumDebugPropertyInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugPropertyInfo> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugPropertyInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugPropertyInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugPropertyInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugPropertyInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, pi: *mut ::core::mem::ManuallyDrop<DebugPropertyInfo>, pceltsfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppepi: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcelt: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugStackFrames(pub ::windows::core::IUnknown);
impl IEnumDebugStackFrames {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Next(&self, celt: u32, prgdsfd: *mut DebugStackFrameDescriptor, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(prgdsfd), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumDebugStackFrames {
type Vtable = IEnumDebugStackFrames_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c1e_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumDebugStackFrames> for ::windows::core::IUnknown {
fn from(value: IEnumDebugStackFrames) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugStackFrames> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugStackFrames) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugStackFrames {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugStackFrames {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugStackFrames_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, prgdsfd: *mut ::core::mem::ManuallyDrop<DebugStackFrameDescriptor>, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumDebugStackFrames64(pub ::windows::core::IUnknown);
impl IEnumDebugStackFrames64 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Next(&self, celt: u32, prgdsfd: *mut DebugStackFrameDescriptor, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(prgdsfd), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Next64(&self, celt: u32, prgdsfd: *mut DebugStackFrameDescriptor64, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(prgdsfd), ::core::mem::transmute(pceltfetched)).ok()
}
}
unsafe impl ::windows::core::Interface for IEnumDebugStackFrames64 {
type Vtable = IEnumDebugStackFrames64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0dc38853_c1b0_4176_a984_b298361027af);
}
impl ::core::convert::From<IEnumDebugStackFrames64> for ::windows::core::IUnknown {
fn from(value: IEnumDebugStackFrames64) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumDebugStackFrames64> for ::windows::core::IUnknown {
fn from(value: &IEnumDebugStackFrames64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumDebugStackFrames64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumDebugStackFrames64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IEnumDebugStackFrames64> for IEnumDebugStackFrames {
fn from(value: IEnumDebugStackFrames64) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IEnumDebugStackFrames64> for IEnumDebugStackFrames {
fn from(value: &IEnumDebugStackFrames64) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IEnumDebugStackFrames> for IEnumDebugStackFrames64 {
fn into_param(self) -> ::windows::core::Param<'a, IEnumDebugStackFrames> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IEnumDebugStackFrames> for &IEnumDebugStackFrames64 {
fn into_param(self) -> ::windows::core::Param<'a, IEnumDebugStackFrames> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumDebugStackFrames64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, prgdsfd: *mut ::core::mem::ManuallyDrop<DebugStackFrameDescriptor>, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, prgdsfd: *mut ::core::mem::ManuallyDrop<DebugStackFrameDescriptor64>, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumJsStackFrames(pub ::windows::core::IUnknown);
impl IEnumJsStackFrames {
pub unsafe fn Next(&self, cframecount: u32, pframes: *mut __MIDL___MIDL_itf_jscript9diag_0000_0007_0001, pcfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(cframecount), ::core::mem::transmute(pframes), ::core::mem::transmute(pcfetched)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IEnumJsStackFrames {
type Vtable = IEnumJsStackFrames_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5e7da34b_fb51_4791_abe7_cb5bdf419755);
}
impl ::core::convert::From<IEnumJsStackFrames> for ::windows::core::IUnknown {
fn from(value: IEnumJsStackFrames) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumJsStackFrames> for ::windows::core::IUnknown {
fn from(value: &IEnumJsStackFrames) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumJsStackFrames {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumJsStackFrames {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumJsStackFrames_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cframecount: u32, pframes: *mut __MIDL___MIDL_itf_jscript9diag_0000_0007_0001, pcfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumRemoteDebugApplicationThreads(pub ::windows::core::IUnknown);
impl IEnumRemoteDebugApplicationThreads {
pub unsafe fn Next(&self, celt: u32, pprdat: *mut ::core::option::Option<IRemoteDebugApplicationThread>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(pprdat), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumRemoteDebugApplicationThreads> {
let mut result__: <IEnumRemoteDebugApplicationThreads as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplicationThreads>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumRemoteDebugApplicationThreads {
type Vtable = IEnumRemoteDebugApplicationThreads_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c3c_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumRemoteDebugApplicationThreads> for ::windows::core::IUnknown {
fn from(value: IEnumRemoteDebugApplicationThreads) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumRemoteDebugApplicationThreads> for ::windows::core::IUnknown {
fn from(value: &IEnumRemoteDebugApplicationThreads) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumRemoteDebugApplicationThreads {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumRemoteDebugApplicationThreads {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumRemoteDebugApplicationThreads_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, pprdat: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperdat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumRemoteDebugApplications(pub ::windows::core::IUnknown);
impl IEnumRemoteDebugApplications {
pub unsafe fn Next(&self, celt: u32, ppda: *mut ::core::option::Option<IRemoteDebugApplication>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(ppda), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumRemoteDebugApplications> {
let mut result__: <IEnumRemoteDebugApplications as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplications>(result__)
}
}
unsafe impl ::windows::core::Interface for IEnumRemoteDebugApplications {
type Vtable = IEnumRemoteDebugApplications_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c3b_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IEnumRemoteDebugApplications> for ::windows::core::IUnknown {
fn from(value: IEnumRemoteDebugApplications) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumRemoteDebugApplications> for ::windows::core::IUnknown {
fn from(value: &IEnumRemoteDebugApplications) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumRemoteDebugApplications {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumRemoteDebugApplications {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumRemoteDebugApplications_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, ppda: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppessd: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEquatableConcept(pub ::windows::core::IUnknown);
impl IEquatableConcept {
pub unsafe fn AreObjectsEqual<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0, otherobject: Param1) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), otherobject.into_param().abi(), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IEquatableConcept {
type Vtable = IEquatableConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc52d5d3d_609d_4d5d_8a82_46b0acdec4f4);
}
impl ::core::convert::From<IEquatableConcept> for ::windows::core::IUnknown {
fn from(value: IEquatableConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IEquatableConcept> for ::windows::core::IUnknown {
fn from(value: &IEquatableConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEquatableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEquatableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEquatableConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, otherobject: ::windows::core::RawPtr, isequal: *mut bool) -> ::windows::core::HRESULT,
);
pub const IG_DISASSEMBLE_BUFFER: u32 = 44u32;
pub const IG_DUMP_SYMBOL_INFO: u32 = 22u32;
pub const IG_FIND_FILE: u32 = 40u32;
pub const IG_GET_ANY_MODULE_IN_RANGE: u32 = 45u32;
pub const IG_GET_BUS_DATA: u32 = 20u32;
pub const IG_GET_CACHE_SIZE: u32 = 32u32;
pub const IG_GET_CLR_DATA_INTERFACE: u32 = 38u32;
pub const IG_GET_CONTEXT_EX: u32 = 48u32;
pub const IG_GET_CURRENT_PROCESS: u32 = 26u32;
pub const IG_GET_CURRENT_PROCESS_HANDLE: u32 = 28u32;
pub const IG_GET_CURRENT_THREAD: u32 = 25u32;
pub const IG_GET_DEBUGGER_DATA: u32 = 14u32;
pub const IG_GET_EXCEPTION_RECORD: u32 = 18u32;
pub const IG_GET_EXPRESSION_EX: u32 = 30u32;
pub const IG_GET_INPUT_LINE: u32 = 29u32;
pub const IG_GET_KERNEL_VERSION: u32 = 15u32;
pub const IG_GET_PEB_ADDRESS: u32 = 129u32;
pub const IG_GET_SET_SYMPATH: u32 = 17u32;
pub const IG_GET_TEB_ADDRESS: u32 = 128u32;
pub const IG_GET_THREAD_OS_INFO: u32 = 37u32;
pub const IG_GET_TYPE_SIZE: u32 = 27u32;
pub const IG_IS_PTR64: u32 = 19u32;
pub const IG_KD_CONTEXT: u32 = 1u32;
pub const IG_KSTACK_HELP: u32 = 10u32;
pub const IG_LOWMEM_CHECK: u32 = 23u32;
pub const IG_MATCH_PATTERN_A: u32 = 39u32;
pub const IG_OBSOLETE_PLACEHOLDER_36: u32 = 36u32;
pub const IG_PHYSICAL_TO_VIRTUAL: u32 = 47u32;
pub const IG_POINTER_SEARCH_PHYSICAL: u32 = 35u32;
pub const IG_QUERY_TARGET_INTERFACE: u32 = 42u32;
pub const IG_READ_CONTROL_SPACE: u32 = 2u32;
pub const IG_READ_IO_SPACE: u32 = 4u32;
pub const IG_READ_IO_SPACE_EX: u32 = 8u32;
pub const IG_READ_MSR: u32 = 12u32;
pub const IG_READ_PHYSICAL: u32 = 6u32;
pub const IG_READ_PHYSICAL_WITH_FLAGS: u32 = 33u32;
pub const IG_RELOAD_SYMBOLS: u32 = 16u32;
pub const IG_SEARCH_MEMORY: u32 = 24u32;
pub const IG_SET_BUS_DATA: u32 = 21u32;
pub const IG_SET_THREAD: u32 = 11u32;
pub const IG_TRANSLATE_VIRTUAL_TO_PHYSICAL: u32 = 31u32;
pub const IG_TYPED_DATA: u32 = 43u32;
pub const IG_TYPED_DATA_OBSOLETE: u32 = 41u32;
pub const IG_VIRTUAL_TO_PHYSICAL: u32 = 46u32;
pub const IG_WRITE_CONTROL_SPACE: u32 = 3u32;
pub const IG_WRITE_IO_SPACE: u32 = 5u32;
pub const IG_WRITE_IO_SPACE_EX: u32 = 9u32;
pub const IG_WRITE_MSR: u32 = 13u32;
pub const IG_WRITE_PHYSICAL: u32 = 7u32;
pub const IG_WRITE_PHYSICAL_WITH_FLAGS: u32 = 34u32;
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IHostDataModelAccess(pub ::windows::core::IUnknown);
impl IHostDataModelAccess {
pub unsafe fn GetDataModel(&self, manager: *mut ::core::option::Option<IDataModelManager>, host: *mut ::core::option::Option<IDebugHost>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(manager), ::core::mem::transmute(host)).ok()
}
}
unsafe impl ::windows::core::Interface for IHostDataModelAccess {
type Vtable = IHostDataModelAccess_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf2bce54e_4835_4f8a_836e_7981e29904d1);
}
impl ::core::convert::From<IHostDataModelAccess> for ::windows::core::IUnknown {
fn from(value: IHostDataModelAccess) -> Self {
value.0
}
}
impl ::core::convert::From<&IHostDataModelAccess> for ::windows::core::IUnknown {
fn from(value: &IHostDataModelAccess) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IHostDataModelAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IHostDataModelAccess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IHostDataModelAccess_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, manager: *mut ::windows::core::RawPtr, host: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IIndexableConcept(pub ::windows::core::IUnknown);
impl IIndexableConcept {
pub unsafe fn GetDimensionality<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetAt<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0, indexercount: u64, indexers: *const ::core::option::Option<IModelObject>, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), ::core::mem::transmute(indexercount), ::core::mem::transmute(indexers), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn SetAt<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param3: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0, indexercount: u64, indexers: *const ::core::option::Option<IModelObject>, value: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), ::core::mem::transmute(indexercount), ::core::mem::transmute(indexers), value.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IIndexableConcept {
type Vtable = IIndexableConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd1fad99f_3f53_4457_850c_8051df2d3fb5);
}
impl ::core::convert::From<IIndexableConcept> for ::windows::core::IUnknown {
fn from(value: IIndexableConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IIndexableConcept> for ::windows::core::IUnknown {
fn from(value: &IIndexableConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IIndexableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IIndexableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IIndexableConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, dimensionality: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, indexercount: u64, indexers: *const ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, indexercount: u64, indexers: *const ::windows::core::RawPtr, value: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IIterableConcept(pub ::windows::core::IUnknown);
impl IIterableConcept {
pub unsafe fn GetDefaultIndexDimensionality<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetIterator<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<IModelIterator> {
let mut result__: <IModelIterator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<IModelIterator>(result__)
}
}
unsafe impl ::windows::core::Interface for IIterableConcept {
type Vtable = IIterableConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf5d49d0c_0b02_4301_9c9b_b3a6037628f3);
}
impl ::core::convert::From<IIterableConcept> for ::windows::core::IUnknown {
fn from(value: IIterableConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IIterableConcept> for ::windows::core::IUnknown {
fn from(value: &IIterableConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IIterableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IIterableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IIterableConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, dimensionality: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, iterator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebug(pub ::windows::core::IUnknown);
impl IJsDebug {
pub unsafe fn OpenVirtualProcess<'a, Param2: ::windows::core::IntoParam<'a, IJsDebugDataTarget>>(&self, processid: u32, runtimejsbaseaddress: u64, pdatatarget: Param2) -> ::windows::core::Result<IJsDebugProcess> {
let mut result__: <IJsDebugProcess as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(processid), ::core::mem::transmute(runtimejsbaseaddress), pdatatarget.into_param().abi(), &mut result__).from_abi::<IJsDebugProcess>(result__)
}
}
unsafe impl ::windows::core::Interface for IJsDebug {
type Vtable = IJsDebug_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbe0e89da_2ac5_4c04_ac5e_59956aae3613);
}
impl ::core::convert::From<IJsDebug> for ::windows::core::IUnknown {
fn from(value: IJsDebug) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebug> for ::windows::core::IUnknown {
fn from(value: &IJsDebug) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebug {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebug_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, processid: u32, runtimejsbaseaddress: u64, pdatatarget: ::windows::core::RawPtr, ppprocess: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugBreakPoint(pub ::windows::core::IUnknown);
impl IJsDebugBreakPoint {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsEnabled(&self) -> ::windows::core::Result<super::super::super::Foundation::BOOL> {
let mut result__: <super::super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BOOL>(result__)
}
pub unsafe fn Enable(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Disable(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Delete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetDocumentPosition(&self, pdocumentid: *mut u64, pcharacteroffset: *mut u32, pstatementcharcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdocumentid), ::core::mem::transmute(pcharacteroffset), ::core::mem::transmute(pstatementcharcount)).ok()
}
}
unsafe impl ::windows::core::Interface for IJsDebugBreakPoint {
type Vtable = IJsDebugBreakPoint_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdf6773e3_ed8d_488b_8a3e_5812577d1542);
}
impl ::core::convert::From<IJsDebugBreakPoint> for ::windows::core::IUnknown {
fn from(value: IJsDebugBreakPoint) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugBreakPoint> for ::windows::core::IUnknown {
fn from(value: &IJsDebugBreakPoint) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugBreakPoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugBreakPoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugBreakPoint_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pisenabled: *mut super::super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdocumentid: *mut u64, pcharacteroffset: *mut u32, pstatementcharcount: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugDataTarget(pub ::windows::core::IUnknown);
impl IJsDebugDataTarget {
pub unsafe fn ReadMemory(&self, address: u64, flags: JsDebugReadMemoryFlags, pbuffer: *mut u8, size: u32, pbytesread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), ::core::mem::transmute(flags), ::core::mem::transmute(pbuffer), ::core::mem::transmute(size), ::core::mem::transmute(pbytesread)).ok()
}
pub unsafe fn WriteMemory(&self, address: u64, pmemory: *const u8, size: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), ::core::mem::transmute(pmemory), ::core::mem::transmute(size)).ok()
}
pub unsafe fn AllocateVirtualMemory(&self, address: u64, size: u32, allocationtype: u32, pageprotection: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), ::core::mem::transmute(size), ::core::mem::transmute(allocationtype), ::core::mem::transmute(pageprotection), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn FreeVirtualMemory(&self, address: u64, size: u32, freetype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), ::core::mem::transmute(size), ::core::mem::transmute(freetype)).ok()
}
pub unsafe fn GetTlsValue(&self, threadid: u32, tlsindex: u32) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(threadid), ::core::mem::transmute(tlsindex), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadBSTR(&self, address: u64) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReadNullTerminatedString(&self, address: u64, charactersize: u16, maxcharacters: u32) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(address), ::core::mem::transmute(charactersize), ::core::mem::transmute(maxcharacters), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn CreateStackFrameEnumerator(&self, threadid: u32) -> ::windows::core::Result<IEnumJsStackFrames> {
let mut result__: <IEnumJsStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(threadid), &mut result__).from_abi::<IEnumJsStackFrames>(result__)
}
pub unsafe fn GetThreadContext(&self, threadid: u32, contextflags: u32, contextsize: u32, pcontext: *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(threadid), ::core::mem::transmute(contextflags), ::core::mem::transmute(contextsize), ::core::mem::transmute(pcontext)).ok()
}
}
unsafe impl ::windows::core::Interface for IJsDebugDataTarget {
type Vtable = IJsDebugDataTarget_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x53b28977_53a1_48e5_9000_5d0dfa893931);
}
impl ::core::convert::From<IJsDebugDataTarget> for ::windows::core::IUnknown {
fn from(value: IJsDebugDataTarget) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugDataTarget> for ::windows::core::IUnknown {
fn from(value: &IJsDebugDataTarget) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugDataTarget {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugDataTarget {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugDataTarget_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, flags: JsDebugReadMemoryFlags, pbuffer: *mut u8, size: u32, pbytesread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, pmemory: *const u8, size: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, size: u32, allocationtype: u32, pageprotection: u32, pallocatedaddress: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, size: u32, freetype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, threadid: u32, tlsindex: u32, pvalue: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, pstring: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, address: u64, charactersize: u16, maxcharacters: u32, pstring: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, threadid: u32, ppenumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, threadid: u32, contextflags: u32, contextsize: u32, pcontext: *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugFrame(pub ::windows::core::IUnknown);
impl IJsDebugFrame {
pub unsafe fn GetStackRange(&self, pstart: *mut u64, pend: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstart), ::core::mem::transmute(pend)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDocumentPositionWithId(&self, pdocumentid: *mut u64, pcharacteroffset: *mut u32, pstatementcharcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdocumentid), ::core::mem::transmute(pcharacteroffset), ::core::mem::transmute(pstatementcharcount)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDocumentPositionWithName(&self, pdocumentname: *mut super::super::super::Foundation::BSTR, pline: *mut u32, pcolumn: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdocumentname), ::core::mem::transmute(pline), ::core::mem::transmute(pcolumn)).ok()
}
pub unsafe fn GetDebugProperty(&self) -> ::windows::core::Result<IJsDebugProperty> {
let mut result__: <IJsDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IJsDebugProperty>(result__)
}
pub unsafe fn GetReturnAddress(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Evaluate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pexpressiontext: Param0, ppdebugproperty: *mut ::core::option::Option<IJsDebugProperty>, perror: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pexpressiontext.into_param().abi(), ::core::mem::transmute(ppdebugproperty), ::core::mem::transmute(perror)).ok()
}
}
unsafe impl ::windows::core::Interface for IJsDebugFrame {
type Vtable = IJsDebugFrame_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9196637_ab9d_44b2_bad2_13b95b3f390e);
}
impl ::core::convert::From<IJsDebugFrame> for ::windows::core::IUnknown {
fn from(value: IJsDebugFrame) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugFrame> for ::windows::core::IUnknown {
fn from(value: &IJsDebugFrame) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugFrame {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugFrame_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstart: *mut u64, pend: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdocumentid: *mut u64, pcharacteroffset: *mut u32, pstatementcharcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdocumentname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pline: *mut u32, pcolumn: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdebugproperty: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, preturnaddress: *mut u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pexpressiontext: super::super::super::Foundation::PWSTR, ppdebugproperty: *mut ::windows::core::RawPtr, perror: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugProcess(pub ::windows::core::IUnknown);
impl IJsDebugProcess {
pub unsafe fn CreateStackWalker(&self, threadid: u32) -> ::windows::core::Result<IJsDebugStackWalker> {
let mut result__: <IJsDebugStackWalker as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(threadid), &mut result__).from_abi::<IJsDebugStackWalker>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateBreakPoint<'a, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(&self, documentid: u64, characteroffset: u32, charactercount: u32, isenabled: Param3) -> ::windows::core::Result<IJsDebugBreakPoint> {
let mut result__: <IJsDebugBreakPoint as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(documentid), ::core::mem::transmute(characteroffset), ::core::mem::transmute(charactercount), isenabled.into_param().abi(), &mut result__).from_abi::<IJsDebugBreakPoint>(result__)
}
pub unsafe fn PerformAsyncBreak(&self, threadid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(threadid)).ok()
}
pub unsafe fn GetExternalStepAddress(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for IJsDebugProcess {
type Vtable = IJsDebugProcess_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3d587168_6a2d_4041_bd3b_0de674502862);
}
impl ::core::convert::From<IJsDebugProcess> for ::windows::core::IUnknown {
fn from(value: IJsDebugProcess) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugProcess> for ::windows::core::IUnknown {
fn from(value: &IJsDebugProcess) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugProcess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugProcess {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugProcess_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, threadid: u32, ppstackwalker: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, documentid: u64, characteroffset: u32, charactercount: u32, isenabled: super::super::super::Foundation::BOOL, ppdebugbreakpoint: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, threadid: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcodeaddress: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugProperty(pub ::windows::core::IUnknown);
impl IJsDebugProperty {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyInfo(&self, nradix: u32) -> ::windows::core::Result<JsDebugPropertyInfo> {
let mut result__: <JsDebugPropertyInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(nradix), &mut result__).from_abi::<JsDebugPropertyInfo>(result__)
}
pub unsafe fn GetMembers(&self, members: JS_PROPERTY_MEMBERS) -> ::windows::core::Result<IJsEnumDebugProperty> {
let mut result__: <IJsEnumDebugProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(members), &mut result__).from_abi::<IJsEnumDebugProperty>(result__)
}
}
unsafe impl ::windows::core::Interface for IJsDebugProperty {
type Vtable = IJsDebugProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf8ffcf2b_3aa4_4320_85c3_52a312ba9633);
}
impl ::core::convert::From<IJsDebugProperty> for ::windows::core::IUnknown {
fn from(value: IJsDebugProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugProperty> for ::windows::core::IUnknown {
fn from(value: &IJsDebugProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nradix: u32, ppropertyinfo: *mut ::core::mem::ManuallyDrop<JsDebugPropertyInfo>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, members: JS_PROPERTY_MEMBERS, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsDebugStackWalker(pub ::windows::core::IUnknown);
impl IJsDebugStackWalker {
pub unsafe fn GetNext(&self) -> ::windows::core::Result<IJsDebugFrame> {
let mut result__: <IJsDebugFrame as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IJsDebugFrame>(result__)
}
}
unsafe impl ::windows::core::Interface for IJsDebugStackWalker {
type Vtable = IJsDebugStackWalker_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xdb24b094_73c4_456c_a4ec_e90ea00bdfe3);
}
impl ::core::convert::From<IJsDebugStackWalker> for ::windows::core::IUnknown {
fn from(value: IJsDebugStackWalker) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsDebugStackWalker> for ::windows::core::IUnknown {
fn from(value: &IJsDebugStackWalker) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsDebugStackWalker {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsDebugStackWalker {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsDebugStackWalker_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppframe: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IJsEnumDebugProperty(pub ::windows::core::IUnknown);
impl IJsEnumDebugProperty {
pub unsafe fn Next(&self, count: u32, ppdebugproperty: *mut ::core::option::Option<IJsDebugProperty>, pactualcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(count), ::core::mem::transmute(ppdebugproperty), ::core::mem::transmute(pactualcount)).ok()
}
pub unsafe fn GetCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IJsEnumDebugProperty {
type Vtable = IJsEnumDebugProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4092432f_2f0f_4fe1_b638_5b74a52cdcbe);
}
impl ::core::convert::From<IJsEnumDebugProperty> for ::windows::core::IUnknown {
fn from(value: IJsEnumDebugProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&IJsEnumDebugProperty> for ::windows::core::IUnknown {
fn from(value: &IJsEnumDebugProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IJsEnumDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IJsEnumDebugProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IJsEnumDebugProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: u32, ppdebugproperty: *mut ::windows::core::RawPtr, pactualcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcount: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IKeyEnumerator(pub ::windows::core::IUnknown);
impl IKeyEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNext(&self, key: *mut super::super::super::Foundation::BSTR, value: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(key), ::core::mem::transmute(value), ::core::mem::transmute(metadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IKeyEnumerator {
type Vtable = IKeyEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x345fa92e_5e00_4319_9cae_971f7601cdcf);
}
impl ::core::convert::From<IKeyEnumerator> for ::windows::core::IUnknown {
fn from(value: IKeyEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IKeyEnumerator> for ::windows::core::IUnknown {
fn from(value: &IKeyEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IKeyEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IKeyEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IKeyEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, value: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IKeyStore(pub ::windows::core::IUnknown);
impl IKeyStore {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, key: Param0, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), key.into_param().abi(), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>, Param2: ::windows::core::IntoParam<'a, IKeyStore>>(&self, key: Param0, object: Param1, metadata: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), key.into_param().abi(), object.into_param().abi(), metadata.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, key: Param0, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), key.into_param().abi(), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, key: Param0, object: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), key.into_param().abi(), object.into_param().abi()).ok()
}
pub unsafe fn ClearKeys(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for IKeyStore {
type Vtable = IKeyStore_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0fc7557d_401d_4fca_9365_da1e9850697c);
}
impl ::core::convert::From<IKeyStore> for ::windows::core::IUnknown {
fn from(value: IKeyStore) -> Self {
value.0
}
}
impl ::core::convert::From<&IKeyStore> for ::windows::core::IUnknown {
fn from(value: &IKeyStore) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IKeyStore {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IKeyStore {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IKeyStore_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_CBA_EVENT {
pub severity: IMAGEHLP_CBA_EVENT_SEVERITY,
pub code: u32,
pub desc: super::super::super::Foundation::PSTR,
pub object: *mut ::core::ffi::c_void,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_CBA_EVENT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_CBA_EVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_CBA_EVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_CBA_EVENT").field("severity", &self.severity).field("code", &self.code).field("desc", &self.desc).field("object", &self.object).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_CBA_EVENT {
fn eq(&self, other: &Self) -> bool {
self.severity == other.severity && self.code == other.code && self.desc == other.desc && self.object == other.object
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_CBA_EVENT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_CBA_EVENT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_CBA_EVENTW {
pub severity: IMAGEHLP_CBA_EVENT_SEVERITY,
pub code: u32,
pub desc: super::super::super::Foundation::PWSTR,
pub object: *mut ::core::ffi::c_void,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_CBA_EVENTW {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_CBA_EVENTW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_CBA_EVENTW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_CBA_EVENTW").field("severity", &self.severity).field("code", &self.code).field("desc", &self.desc).field("object", &self.object).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_CBA_EVENTW {
fn eq(&self, other: &Self) -> bool {
self.severity == other.severity && self.code == other.code && self.desc == other.desc && self.object == other.object
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_CBA_EVENTW {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_CBA_EVENTW {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_CBA_EVENT_SEVERITY(pub u32);
pub const sevInfo: IMAGEHLP_CBA_EVENT_SEVERITY = IMAGEHLP_CBA_EVENT_SEVERITY(0u32);
pub const sevProblem: IMAGEHLP_CBA_EVENT_SEVERITY = IMAGEHLP_CBA_EVENT_SEVERITY(1u32);
pub const sevAttn: IMAGEHLP_CBA_EVENT_SEVERITY = IMAGEHLP_CBA_EVENT_SEVERITY(2u32);
pub const sevFatal: IMAGEHLP_CBA_EVENT_SEVERITY = IMAGEHLP_CBA_EVENT_SEVERITY(3u32);
impl ::core::convert::From<u32> for IMAGEHLP_CBA_EVENT_SEVERITY {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_CBA_EVENT_SEVERITY {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGEHLP_CBA_EVENT_SEVERITY {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGEHLP_CBA_EVENT_SEVERITY {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGEHLP_CBA_EVENT_SEVERITY {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGEHLP_CBA_EVENT_SEVERITY {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGEHLP_CBA_EVENT_SEVERITY {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGEHLP_CBA_READ_MEMORY {
pub addr: u64,
pub buf: *mut ::core::ffi::c_void,
pub bytes: u32,
pub bytesread: *mut u32,
}
impl IMAGEHLP_CBA_READ_MEMORY {}
impl ::core::default::Default for IMAGEHLP_CBA_READ_MEMORY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGEHLP_CBA_READ_MEMORY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_CBA_READ_MEMORY").field("addr", &self.addr).field("buf", &self.buf).field("bytes", &self.bytes).field("bytesread", &self.bytesread).finish()
}
}
impl ::core::cmp::PartialEq for IMAGEHLP_CBA_READ_MEMORY {
fn eq(&self, other: &Self) -> bool {
self.addr == other.addr && self.buf == other.buf && self.bytes == other.bytes && self.bytesread == other.bytesread
}
}
impl ::core::cmp::Eq for IMAGEHLP_CBA_READ_MEMORY {}
unsafe impl ::windows::core::Abi for IMAGEHLP_CBA_READ_MEMORY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_DEFERRED_SYMBOL_LOAD {
pub SizeOfStruct: u32,
pub BaseOfImage: u32,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub FileName: [super::super::super::Foundation::CHAR; 260],
pub Reparse: super::super::super::Foundation::BOOLEAN,
pub hFile: super::super::super::Foundation::HANDLE,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_DEFERRED_SYMBOL_LOAD {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_DEFERRED_SYMBOL_LOAD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_DEFERRED_SYMBOL_LOAD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_DEFERRED_SYMBOL_LOAD")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("CheckSum", &self.CheckSum)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("FileName", &self.FileName)
.field("Reparse", &self.Reparse)
.field("hFile", &self.hFile)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_DEFERRED_SYMBOL_LOAD {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.BaseOfImage == other.BaseOfImage && self.CheckSum == other.CheckSum && self.TimeDateStamp == other.TimeDateStamp && self.FileName == other.FileName && self.Reparse == other.Reparse && self.hFile == other.hFile
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_DEFERRED_SYMBOL_LOAD {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_DEFERRED_SYMBOL_LOAD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
pub SizeOfStruct: u32,
pub BaseOfImage: u64,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub FileName: [super::super::super::Foundation::CHAR; 260],
pub Reparse: super::super::super::Foundation::BOOLEAN,
pub hFile: super::super::super::Foundation::HANDLE,
pub Flags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_DEFERRED_SYMBOL_LOAD64")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("CheckSum", &self.CheckSum)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("FileName", &self.FileName)
.field("Reparse", &self.Reparse)
.field("hFile", &self.hFile)
.field("Flags", &self.Flags)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.BaseOfImage == other.BaseOfImage && self.CheckSum == other.CheckSum && self.TimeDateStamp == other.TimeDateStamp && self.FileName == other.FileName && self.Reparse == other.Reparse && self.hFile == other.hFile && self.Flags == other.Flags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_DEFERRED_SYMBOL_LOAD64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
pub SizeOfStruct: u32,
pub BaseOfImage: u64,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub FileName: [u16; 261],
pub Reparse: super::super::super::Foundation::BOOLEAN,
pub hFile: super::super::super::Foundation::HANDLE,
pub Flags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_DEFERRED_SYMBOL_LOADW64")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("CheckSum", &self.CheckSum)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("FileName", &self.FileName)
.field("Reparse", &self.Reparse)
.field("hFile", &self.hFile)
.field("Flags", &self.Flags)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.BaseOfImage == other.BaseOfImage && self.CheckSum == other.CheckSum && self.TimeDateStamp == other.TimeDateStamp && self.FileName == other.FileName && self.Reparse == other.Reparse && self.hFile == other.hFile && self.Flags == other.Flags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_DEFERRED_SYMBOL_LOADW64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_DUPLICATE_SYMBOL {
pub SizeOfStruct: u32,
pub NumberOfDups: u32,
pub Symbol: *mut IMAGEHLP_SYMBOL,
pub SelectedSymbol: u32,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_DUPLICATE_SYMBOL {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_DUPLICATE_SYMBOL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_DUPLICATE_SYMBOL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_DUPLICATE_SYMBOL").field("SizeOfStruct", &self.SizeOfStruct).field("NumberOfDups", &self.NumberOfDups).field("Symbol", &self.Symbol).field("SelectedSymbol", &self.SelectedSymbol).finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_DUPLICATE_SYMBOL {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.NumberOfDups == other.NumberOfDups && self.Symbol == other.Symbol && self.SelectedSymbol == other.SelectedSymbol
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_DUPLICATE_SYMBOL {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_DUPLICATE_SYMBOL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_DUPLICATE_SYMBOL64 {
pub SizeOfStruct: u32,
pub NumberOfDups: u32,
pub Symbol: *mut IMAGEHLP_SYMBOL64,
pub SelectedSymbol: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_DUPLICATE_SYMBOL64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_DUPLICATE_SYMBOL64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_DUPLICATE_SYMBOL64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_DUPLICATE_SYMBOL64").field("SizeOfStruct", &self.SizeOfStruct).field("NumberOfDups", &self.NumberOfDups).field("Symbol", &self.Symbol).field("SelectedSymbol", &self.SelectedSymbol).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_DUPLICATE_SYMBOL64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.NumberOfDups == other.NumberOfDups && self.Symbol == other.Symbol && self.SelectedSymbol == other.SelectedSymbol
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_DUPLICATE_SYMBOL64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_DUPLICATE_SYMBOL64 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_EXTENDED_OPTIONS(pub i32);
pub const SYMOPT_EX_DISABLEACCESSTIMEUPDATE: IMAGEHLP_EXTENDED_OPTIONS = IMAGEHLP_EXTENDED_OPTIONS(0i32);
pub const SYMOPT_EX_LASTVALIDDEBUGDIRECTORY: IMAGEHLP_EXTENDED_OPTIONS = IMAGEHLP_EXTENDED_OPTIONS(1i32);
pub const SYMOPT_EX_NOIMPLICITPATTERNSEARCH: IMAGEHLP_EXTENDED_OPTIONS = IMAGEHLP_EXTENDED_OPTIONS(2i32);
pub const SYMOPT_EX_NEVERLOADSYMBOLS: IMAGEHLP_EXTENDED_OPTIONS = IMAGEHLP_EXTENDED_OPTIONS(3i32);
pub const SYMOPT_EX_MAX: IMAGEHLP_EXTENDED_OPTIONS = IMAGEHLP_EXTENDED_OPTIONS(4i32);
impl ::core::convert::From<i32> for IMAGEHLP_EXTENDED_OPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_EXTENDED_OPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_GET_TYPE_INFO_FLAGS(pub u32);
pub const IMAGEHLP_GET_TYPE_INFO_CHILDREN: IMAGEHLP_GET_TYPE_INFO_FLAGS = IMAGEHLP_GET_TYPE_INFO_FLAGS(2u32);
pub const IMAGEHLP_GET_TYPE_INFO_UNCACHED: IMAGEHLP_GET_TYPE_INFO_FLAGS = IMAGEHLP_GET_TYPE_INFO_FLAGS(1u32);
impl ::core::convert::From<u32> for IMAGEHLP_GET_TYPE_INFO_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_GET_TYPE_INFO_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGEHLP_GET_TYPE_INFO_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGEHLP_GET_TYPE_INFO_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGEHLP_GET_TYPE_INFO_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGEHLP_GET_TYPE_INFO_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGEHLP_GET_TYPE_INFO_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGEHLP_GET_TYPE_INFO_PARAMS {
pub SizeOfStruct: u32,
pub Flags: IMAGEHLP_GET_TYPE_INFO_FLAGS,
pub NumIds: u32,
pub TypeIds: *mut u32,
pub TagFilter: u64,
pub NumReqs: u32,
pub ReqKinds: *mut IMAGEHLP_SYMBOL_TYPE_INFO,
pub ReqOffsets: *mut usize,
pub ReqSizes: *mut u32,
pub ReqStride: usize,
pub BufferSize: usize,
pub Buffer: *mut ::core::ffi::c_void,
pub EntriesMatched: u32,
pub EntriesFilled: u32,
pub TagsFound: u64,
pub AllReqsValid: u64,
pub NumReqsValid: u32,
pub ReqsValid: *mut u64,
}
impl IMAGEHLP_GET_TYPE_INFO_PARAMS {}
impl ::core::default::Default for IMAGEHLP_GET_TYPE_INFO_PARAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGEHLP_GET_TYPE_INFO_PARAMS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_GET_TYPE_INFO_PARAMS")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("Flags", &self.Flags)
.field("NumIds", &self.NumIds)
.field("TypeIds", &self.TypeIds)
.field("TagFilter", &self.TagFilter)
.field("NumReqs", &self.NumReqs)
.field("ReqKinds", &self.ReqKinds)
.field("ReqOffsets", &self.ReqOffsets)
.field("ReqSizes", &self.ReqSizes)
.field("ReqStride", &self.ReqStride)
.field("BufferSize", &self.BufferSize)
.field("Buffer", &self.Buffer)
.field("EntriesMatched", &self.EntriesMatched)
.field("EntriesFilled", &self.EntriesFilled)
.field("TagsFound", &self.TagsFound)
.field("AllReqsValid", &self.AllReqsValid)
.field("NumReqsValid", &self.NumReqsValid)
.field("ReqsValid", &self.ReqsValid)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGEHLP_GET_TYPE_INFO_PARAMS {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct
&& self.Flags == other.Flags
&& self.NumIds == other.NumIds
&& self.TypeIds == other.TypeIds
&& self.TagFilter == other.TagFilter
&& self.NumReqs == other.NumReqs
&& self.ReqKinds == other.ReqKinds
&& self.ReqOffsets == other.ReqOffsets
&& self.ReqSizes == other.ReqSizes
&& self.ReqStride == other.ReqStride
&& self.BufferSize == other.BufferSize
&& self.Buffer == other.Buffer
&& self.EntriesMatched == other.EntriesMatched
&& self.EntriesFilled == other.EntriesFilled
&& self.TagsFound == other.TagsFound
&& self.AllReqsValid == other.AllReqsValid
&& self.NumReqsValid == other.NumReqsValid
&& self.ReqsValid == other.ReqsValid
}
}
impl ::core::cmp::Eq for IMAGEHLP_GET_TYPE_INFO_PARAMS {}
unsafe impl ::windows::core::Abi for IMAGEHLP_GET_TYPE_INFO_PARAMS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_HD_TYPE(pub i32);
pub const hdBase: IMAGEHLP_HD_TYPE = IMAGEHLP_HD_TYPE(0i32);
pub const hdSym: IMAGEHLP_HD_TYPE = IMAGEHLP_HD_TYPE(1i32);
pub const hdSrc: IMAGEHLP_HD_TYPE = IMAGEHLP_HD_TYPE(2i32);
pub const hdMax: IMAGEHLP_HD_TYPE = IMAGEHLP_HD_TYPE(3i32);
impl ::core::convert::From<i32> for IMAGEHLP_HD_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_HD_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_LINE {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub LineNumber: u32,
pub FileName: super::super::super::Foundation::PSTR,
pub Address: u32,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_LINE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_LINE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_LINE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_LINE").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("LineNumber", &self.LineNumber).field("FileName", &self.FileName).field("Address", &self.Address).finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_LINE {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.LineNumber == other.LineNumber && self.FileName == other.FileName && self.Address == other.Address
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_LINE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_LINE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_LINE64 {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub LineNumber: u32,
pub FileName: super::super::super::Foundation::PSTR,
pub Address: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_LINE64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_LINE64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_LINE64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_LINE64").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("LineNumber", &self.LineNumber).field("FileName", &self.FileName).field("Address", &self.Address).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_LINE64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.LineNumber == other.LineNumber && self.FileName == other.FileName && self.Address == other.Address
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_LINE64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_LINE64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_LINEW {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub LineNumber: u32,
pub FileName: super::super::super::Foundation::PSTR,
pub Address: u64,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_LINEW {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_LINEW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_LINEW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_LINEW").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("LineNumber", &self.LineNumber).field("FileName", &self.FileName).field("Address", &self.Address).finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_LINEW {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.LineNumber == other.LineNumber && self.FileName == other.FileName && self.Address == other.Address
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_LINEW {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_LINEW {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_LINEW64 {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub LineNumber: u32,
pub FileName: super::super::super::Foundation::PWSTR,
pub Address: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_LINEW64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_LINEW64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_LINEW64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_LINEW64").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("LineNumber", &self.LineNumber).field("FileName", &self.FileName).field("Address", &self.Address).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_LINEW64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.LineNumber == other.LineNumber && self.FileName == other.FileName && self.Address == other.Address
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_LINEW64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_LINEW64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_MODULE {
pub SizeOfStruct: u32,
pub BaseOfImage: u32,
pub ImageSize: u32,
pub TimeDateStamp: u32,
pub CheckSum: u32,
pub NumSyms: u32,
pub SymType: SYM_TYPE,
pub ModuleName: [super::super::super::Foundation::CHAR; 32],
pub ImageName: [super::super::super::Foundation::CHAR; 256],
pub LoadedImageName: [super::super::super::Foundation::CHAR; 256],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_MODULE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_MODULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_MODULE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULE")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("ImageSize", &self.ImageSize)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("CheckSum", &self.CheckSum)
.field("NumSyms", &self.NumSyms)
.field("SymType", &self.SymType)
.field("ModuleName", &self.ModuleName)
.field("ImageName", &self.ImageName)
.field("LoadedImageName", &self.LoadedImageName)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULE {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.BaseOfImage == other.BaseOfImage && self.ImageSize == other.ImageSize && self.TimeDateStamp == other.TimeDateStamp && self.CheckSum == other.CheckSum && self.NumSyms == other.NumSyms && self.SymType == other.SymType && self.ModuleName == other.ModuleName && self.ImageName == other.ImageName && self.LoadedImageName == other.LoadedImageName
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_MODULE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_MODULE64 {
pub SizeOfStruct: u32,
pub BaseOfImage: u64,
pub ImageSize: u32,
pub TimeDateStamp: u32,
pub CheckSum: u32,
pub NumSyms: u32,
pub SymType: SYM_TYPE,
pub ModuleName: [super::super::super::Foundation::CHAR; 32],
pub ImageName: [super::super::super::Foundation::CHAR; 256],
pub LoadedImageName: [super::super::super::Foundation::CHAR; 256],
pub LoadedPdbName: [super::super::super::Foundation::CHAR; 256],
pub CVSig: u32,
pub CVData: [super::super::super::Foundation::CHAR; 780],
pub PdbSig: u32,
pub PdbSig70: ::windows::core::GUID,
pub PdbAge: u32,
pub PdbUnmatched: super::super::super::Foundation::BOOL,
pub DbgUnmatched: super::super::super::Foundation::BOOL,
pub LineNumbers: super::super::super::Foundation::BOOL,
pub GlobalSymbols: super::super::super::Foundation::BOOL,
pub TypeInfo: super::super::super::Foundation::BOOL,
pub SourceIndexed: super::super::super::Foundation::BOOL,
pub Publics: super::super::super::Foundation::BOOL,
pub MachineType: u32,
pub Reserved: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_MODULE64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_MODULE64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_MODULE64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULE64")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("ImageSize", &self.ImageSize)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("CheckSum", &self.CheckSum)
.field("NumSyms", &self.NumSyms)
.field("SymType", &self.SymType)
.field("ModuleName", &self.ModuleName)
.field("ImageName", &self.ImageName)
.field("LoadedImageName", &self.LoadedImageName)
.field("LoadedPdbName", &self.LoadedPdbName)
.field("CVSig", &self.CVSig)
.field("CVData", &self.CVData)
.field("PdbSig", &self.PdbSig)
.field("PdbSig70", &self.PdbSig70)
.field("PdbAge", &self.PdbAge)
.field("PdbUnmatched", &self.PdbUnmatched)
.field("DbgUnmatched", &self.DbgUnmatched)
.field("LineNumbers", &self.LineNumbers)
.field("GlobalSymbols", &self.GlobalSymbols)
.field("TypeInfo", &self.TypeInfo)
.field("SourceIndexed", &self.SourceIndexed)
.field("Publics", &self.Publics)
.field("MachineType", &self.MachineType)
.field("Reserved", &self.Reserved)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULE64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct
&& self.BaseOfImage == other.BaseOfImage
&& self.ImageSize == other.ImageSize
&& self.TimeDateStamp == other.TimeDateStamp
&& self.CheckSum == other.CheckSum
&& self.NumSyms == other.NumSyms
&& self.SymType == other.SymType
&& self.ModuleName == other.ModuleName
&& self.ImageName == other.ImageName
&& self.LoadedImageName == other.LoadedImageName
&& self.LoadedPdbName == other.LoadedPdbName
&& self.CVSig == other.CVSig
&& self.CVData == other.CVData
&& self.PdbSig == other.PdbSig
&& self.PdbSig70 == other.PdbSig70
&& self.PdbAge == other.PdbAge
&& self.PdbUnmatched == other.PdbUnmatched
&& self.DbgUnmatched == other.DbgUnmatched
&& self.LineNumbers == other.LineNumbers
&& self.GlobalSymbols == other.GlobalSymbols
&& self.TypeInfo == other.TypeInfo
&& self.SourceIndexed == other.SourceIndexed
&& self.Publics == other.Publics
&& self.MachineType == other.MachineType
&& self.Reserved == other.Reserved
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_MODULE64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULE64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_MODULE64_EX {
pub Module: IMAGEHLP_MODULE64,
pub RegionFlags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_MODULE64_EX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_MODULE64_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_MODULE64_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULE64_EX").field("Module", &self.Module).field("RegionFlags", &self.RegionFlags).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULE64_EX {
fn eq(&self, other: &Self) -> bool {
self.Module == other.Module && self.RegionFlags == other.RegionFlags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_MODULE64_EX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULE64_EX {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct IMAGEHLP_MODULEW {
pub SizeOfStruct: u32,
pub BaseOfImage: u32,
pub ImageSize: u32,
pub TimeDateStamp: u32,
pub CheckSum: u32,
pub NumSyms: u32,
pub SymType: SYM_TYPE,
pub ModuleName: [u16; 32],
pub ImageName: [u16; 256],
pub LoadedImageName: [u16; 256],
}
#[cfg(any(target_arch = "x86",))]
impl IMAGEHLP_MODULEW {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for IMAGEHLP_MODULEW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for IMAGEHLP_MODULEW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULEW")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("ImageSize", &self.ImageSize)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("CheckSum", &self.CheckSum)
.field("NumSyms", &self.NumSyms)
.field("SymType", &self.SymType)
.field("ModuleName", &self.ModuleName)
.field("ImageName", &self.ImageName)
.field("LoadedImageName", &self.LoadedImageName)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULEW {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.BaseOfImage == other.BaseOfImage && self.ImageSize == other.ImageSize && self.TimeDateStamp == other.TimeDateStamp && self.CheckSum == other.CheckSum && self.NumSyms == other.NumSyms && self.SymType == other.SymType && self.ModuleName == other.ModuleName && self.ImageName == other.ImageName && self.LoadedImageName == other.LoadedImageName
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for IMAGEHLP_MODULEW {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULEW {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_MODULEW64 {
pub SizeOfStruct: u32,
pub BaseOfImage: u64,
pub ImageSize: u32,
pub TimeDateStamp: u32,
pub CheckSum: u32,
pub NumSyms: u32,
pub SymType: SYM_TYPE,
pub ModuleName: [u16; 32],
pub ImageName: [u16; 256],
pub LoadedImageName: [u16; 256],
pub LoadedPdbName: [u16; 256],
pub CVSig: u32,
pub CVData: [u16; 780],
pub PdbSig: u32,
pub PdbSig70: ::windows::core::GUID,
pub PdbAge: u32,
pub PdbUnmatched: super::super::super::Foundation::BOOL,
pub DbgUnmatched: super::super::super::Foundation::BOOL,
pub LineNumbers: super::super::super::Foundation::BOOL,
pub GlobalSymbols: super::super::super::Foundation::BOOL,
pub TypeInfo: super::super::super::Foundation::BOOL,
pub SourceIndexed: super::super::super::Foundation::BOOL,
pub Publics: super::super::super::Foundation::BOOL,
pub MachineType: u32,
pub Reserved: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_MODULEW64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_MODULEW64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_MODULEW64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULEW64")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("BaseOfImage", &self.BaseOfImage)
.field("ImageSize", &self.ImageSize)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("CheckSum", &self.CheckSum)
.field("NumSyms", &self.NumSyms)
.field("SymType", &self.SymType)
.field("ModuleName", &self.ModuleName)
.field("ImageName", &self.ImageName)
.field("LoadedImageName", &self.LoadedImageName)
.field("LoadedPdbName", &self.LoadedPdbName)
.field("CVSig", &self.CVSig)
.field("CVData", &self.CVData)
.field("PdbSig", &self.PdbSig)
.field("PdbSig70", &self.PdbSig70)
.field("PdbAge", &self.PdbAge)
.field("PdbUnmatched", &self.PdbUnmatched)
.field("DbgUnmatched", &self.DbgUnmatched)
.field("LineNumbers", &self.LineNumbers)
.field("GlobalSymbols", &self.GlobalSymbols)
.field("TypeInfo", &self.TypeInfo)
.field("SourceIndexed", &self.SourceIndexed)
.field("Publics", &self.Publics)
.field("MachineType", &self.MachineType)
.field("Reserved", &self.Reserved)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULEW64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct
&& self.BaseOfImage == other.BaseOfImage
&& self.ImageSize == other.ImageSize
&& self.TimeDateStamp == other.TimeDateStamp
&& self.CheckSum == other.CheckSum
&& self.NumSyms == other.NumSyms
&& self.SymType == other.SymType
&& self.ModuleName == other.ModuleName
&& self.ImageName == other.ImageName
&& self.LoadedImageName == other.LoadedImageName
&& self.LoadedPdbName == other.LoadedPdbName
&& self.CVSig == other.CVSig
&& self.CVData == other.CVData
&& self.PdbSig == other.PdbSig
&& self.PdbSig70 == other.PdbSig70
&& self.PdbAge == other.PdbAge
&& self.PdbUnmatched == other.PdbUnmatched
&& self.DbgUnmatched == other.DbgUnmatched
&& self.LineNumbers == other.LineNumbers
&& self.GlobalSymbols == other.GlobalSymbols
&& self.TypeInfo == other.TypeInfo
&& self.SourceIndexed == other.SourceIndexed
&& self.Publics == other.Publics
&& self.MachineType == other.MachineType
&& self.Reserved == other.Reserved
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_MODULEW64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULEW64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_MODULEW64_EX {
pub Module: IMAGEHLP_MODULEW64,
pub RegionFlags: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_MODULEW64_EX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_MODULEW64_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_MODULEW64_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_MODULEW64_EX").field("Module", &self.Module).field("RegionFlags", &self.RegionFlags).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_MODULEW64_EX {
fn eq(&self, other: &Self) -> bool {
self.Module == other.Module && self.RegionFlags == other.RegionFlags
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_MODULEW64_EX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_MODULEW64_EX {
type Abi = Self;
}
pub const IMAGEHLP_MODULE_REGION_ADDITIONAL: u32 = 4u32;
pub const IMAGEHLP_MODULE_REGION_ALL: u32 = 255u32;
pub const IMAGEHLP_MODULE_REGION_DLLBASE: u32 = 1u32;
pub const IMAGEHLP_MODULE_REGION_DLLRANGE: u32 = 2u32;
pub const IMAGEHLP_MODULE_REGION_JIT: u32 = 8u32;
pub const IMAGEHLP_RMAP_BIG_ENDIAN: u32 = 2u32;
pub const IMAGEHLP_RMAP_FIXUP_ARM64X: u32 = 268435456u32;
pub const IMAGEHLP_RMAP_FIXUP_IMAGEBASE: u32 = 2147483648u32;
pub const IMAGEHLP_RMAP_IGNORE_MISCOMPARE: u32 = 4u32;
pub const IMAGEHLP_RMAP_LOAD_RW_DATA_SECTIONS: u32 = 536870912u32;
pub const IMAGEHLP_RMAP_MAPPED_FLAT: u32 = 1u32;
pub const IMAGEHLP_RMAP_OMIT_SHARED_RW_DATA_SECTIONS: u32 = 1073741824u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_SF_TYPE(pub i32);
pub const sfImage: IMAGEHLP_SF_TYPE = IMAGEHLP_SF_TYPE(0i32);
pub const sfDbg: IMAGEHLP_SF_TYPE = IMAGEHLP_SF_TYPE(1i32);
pub const sfPdb: IMAGEHLP_SF_TYPE = IMAGEHLP_SF_TYPE(2i32);
pub const sfMpd: IMAGEHLP_SF_TYPE = IMAGEHLP_SF_TYPE(3i32);
pub const sfMax: IMAGEHLP_SF_TYPE = IMAGEHLP_SF_TYPE(4i32);
impl ::core::convert::From<i32> for IMAGEHLP_SF_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_SF_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_STACK_FRAME {
pub InstructionOffset: u64,
pub ReturnOffset: u64,
pub FrameOffset: u64,
pub StackOffset: u64,
pub BackingStoreOffset: u64,
pub FuncTableEntry: u64,
pub Params: [u64; 4],
pub Reserved: [u64; 5],
pub Virtual: super::super::super::Foundation::BOOL,
pub Reserved2: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_STACK_FRAME {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_STACK_FRAME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_STACK_FRAME {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_STACK_FRAME")
.field("InstructionOffset", &self.InstructionOffset)
.field("ReturnOffset", &self.ReturnOffset)
.field("FrameOffset", &self.FrameOffset)
.field("StackOffset", &self.StackOffset)
.field("BackingStoreOffset", &self.BackingStoreOffset)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Reserved", &self.Reserved)
.field("Virtual", &self.Virtual)
.field("Reserved2", &self.Reserved2)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_STACK_FRAME {
fn eq(&self, other: &Self) -> bool {
self.InstructionOffset == other.InstructionOffset && self.ReturnOffset == other.ReturnOffset && self.FrameOffset == other.FrameOffset && self.StackOffset == other.StackOffset && self.BackingStoreOffset == other.BackingStoreOffset && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Reserved == other.Reserved && self.Virtual == other.Virtual && self.Reserved2 == other.Reserved2
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_STACK_FRAME {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_STACK_FRAME {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_STATUS_REASON(pub i32);
pub const BindOutOfMemory: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(0i32);
pub const BindRvaToVaFailed: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(1i32);
pub const BindNoRoomInImage: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(2i32);
pub const BindImportModuleFailed: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(3i32);
pub const BindImportProcedureFailed: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(4i32);
pub const BindImportModule: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(5i32);
pub const BindImportProcedure: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(6i32);
pub const BindForwarder: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(7i32);
pub const BindForwarderNOT: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(8i32);
pub const BindImageModified: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(9i32);
pub const BindExpandFileHeaders: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(10i32);
pub const BindImageComplete: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(11i32);
pub const BindMismatchedSymbols: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(12i32);
pub const BindSymbolsNotUpdated: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(13i32);
pub const BindImportProcedure32: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(14i32);
pub const BindImportProcedure64: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(15i32);
pub const BindForwarder32: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(16i32);
pub const BindForwarder64: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(17i32);
pub const BindForwarderNOT32: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(18i32);
pub const BindForwarderNOT64: IMAGEHLP_STATUS_REASON = IMAGEHLP_STATUS_REASON(19i32);
impl ::core::convert::From<i32> for IMAGEHLP_STATUS_REASON {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_STATUS_REASON {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_SYMBOL {
pub SizeOfStruct: u32,
pub Address: u32,
pub Size: u32,
pub Flags: u32,
pub MaxNameLength: u32,
pub Name: [super::super::super::Foundation::CHAR; 1],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_SYMBOL {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_SYMBOL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOL").field("SizeOfStruct", &self.SizeOfStruct).field("Address", &self.Address).field("Size", &self.Size).field("Flags", &self.Flags).field("MaxNameLength", &self.MaxNameLength).field("Name", &self.Name).finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOL {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Address == other.Address && self.Size == other.Size && self.Flags == other.Flags && self.MaxNameLength == other.MaxNameLength && self.Name == other.Name
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOL {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_SYMBOL64 {
pub SizeOfStruct: u32,
pub Address: u64,
pub Size: u32,
pub Flags: u32,
pub MaxNameLength: u32,
pub Name: [super::super::super::Foundation::CHAR; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_SYMBOL64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_SYMBOL64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOL64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOL64").field("SizeOfStruct", &self.SizeOfStruct).field("Address", &self.Address).field("Size", &self.Size).field("Flags", &self.Flags).field("MaxNameLength", &self.MaxNameLength).field("Name", &self.Name).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOL64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Address == other.Address && self.Size == other.Size && self.Flags == other.Flags && self.MaxNameLength == other.MaxNameLength && self.Name == other.Name
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOL64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_SYMBOL64_PACKAGE {
pub sym: IMAGEHLP_SYMBOL64,
pub name: [super::super::super::Foundation::CHAR; 2001],
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_SYMBOL64_PACKAGE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_SYMBOL64_PACKAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOL64_PACKAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOL64_PACKAGE").field("sym", &self.sym).field("name", &self.name).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOL64_PACKAGE {
fn eq(&self, other: &Self) -> bool {
self.sym == other.sym && self.name == other.name
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOL64_PACKAGE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL64_PACKAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct IMAGEHLP_SYMBOLW {
pub SizeOfStruct: u32,
pub Address: u32,
pub Size: u32,
pub Flags: u32,
pub MaxNameLength: u32,
pub Name: [u16; 1],
}
#[cfg(any(target_arch = "x86",))]
impl IMAGEHLP_SYMBOLW {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for IMAGEHLP_SYMBOLW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOLW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOLW").field("SizeOfStruct", &self.SizeOfStruct).field("Address", &self.Address).field("Size", &self.Size).field("Flags", &self.Flags).field("MaxNameLength", &self.MaxNameLength).field("Name", &self.Name).finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOLW {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Address == other.Address && self.Size == other.Size && self.Flags == other.Flags && self.MaxNameLength == other.MaxNameLength && self.Name == other.Name
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOLW {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOLW {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGEHLP_SYMBOLW64 {
pub SizeOfStruct: u32,
pub Address: u64,
pub Size: u32,
pub Flags: u32,
pub MaxNameLength: u32,
pub Name: [u16; 1],
}
impl IMAGEHLP_SYMBOLW64 {}
impl ::core::default::Default for IMAGEHLP_SYMBOLW64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGEHLP_SYMBOLW64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOLW64").field("SizeOfStruct", &self.SizeOfStruct).field("Address", &self.Address).field("Size", &self.Size).field("Flags", &self.Flags).field("MaxNameLength", &self.MaxNameLength).field("Name", &self.Name).finish()
}
}
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOLW64 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Address == other.Address && self.Size == other.Size && self.Flags == other.Flags && self.MaxNameLength == other.MaxNameLength && self.Name == other.Name
}
}
impl ::core::cmp::Eq for IMAGEHLP_SYMBOLW64 {}
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOLW64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGEHLP_SYMBOLW64_PACKAGE {
pub sym: IMAGEHLP_SYMBOLW64,
pub name: [u16; 2001],
}
impl IMAGEHLP_SYMBOLW64_PACKAGE {}
impl ::core::default::Default for IMAGEHLP_SYMBOLW64_PACKAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGEHLP_SYMBOLW64_PACKAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOLW64_PACKAGE").field("sym", &self.sym).field("name", &self.name).finish()
}
}
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOLW64_PACKAGE {
fn eq(&self, other: &Self) -> bool {
self.sym == other.sym && self.name == other.name
}
}
impl ::core::cmp::Eq for IMAGEHLP_SYMBOLW64_PACKAGE {}
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOLW64_PACKAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct IMAGEHLP_SYMBOLW_PACKAGE {
pub sym: IMAGEHLP_SYMBOLW,
pub name: [u16; 2001],
}
#[cfg(any(target_arch = "x86",))]
impl IMAGEHLP_SYMBOLW_PACKAGE {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for IMAGEHLP_SYMBOLW_PACKAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOLW_PACKAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOLW_PACKAGE").field("sym", &self.sym).field("name", &self.name).finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOLW_PACKAGE {
fn eq(&self, other: &Self) -> bool {
self.sym == other.sym && self.name == other.name
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOLW_PACKAGE {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOLW_PACKAGE {
type Abi = Self;
}
pub const IMAGEHLP_SYMBOL_FUNCTION: u32 = 2048u32;
pub const IMAGEHLP_SYMBOL_INFO_CONSTANT: u32 = 256u32;
pub const IMAGEHLP_SYMBOL_INFO_FRAMERELATIVE: u32 = 32u32;
pub const IMAGEHLP_SYMBOL_INFO_LOCAL: u32 = 128u32;
pub const IMAGEHLP_SYMBOL_INFO_PARAMETER: u32 = 64u32;
pub const IMAGEHLP_SYMBOL_INFO_REGISTER: u32 = 8u32;
pub const IMAGEHLP_SYMBOL_INFO_REGRELATIVE: u32 = 16u32;
pub const IMAGEHLP_SYMBOL_INFO_TLSRELATIVE: u32 = 16384u32;
pub const IMAGEHLP_SYMBOL_INFO_VALUEPRESENT: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_SYMBOL_PACKAGE {
pub sym: IMAGEHLP_SYMBOL,
pub name: [super::super::super::Foundation::CHAR; 2001],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_SYMBOL_PACKAGE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_SYMBOL_PACKAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOL_PACKAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOL_PACKAGE").field("sym", &self.sym).field("name", &self.name).finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOL_PACKAGE {
fn eq(&self, other: &Self) -> bool {
self.sym == other.sym && self.name == other.name
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOL_PACKAGE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL_PACKAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct IMAGEHLP_SYMBOL_SRC {
pub sizeofstruct: u32,
pub r#type: u32,
pub file: [super::super::super::Foundation::CHAR; 260],
}
#[cfg(feature = "Win32_Foundation")]
impl IMAGEHLP_SYMBOL_SRC {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for IMAGEHLP_SYMBOL_SRC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for IMAGEHLP_SYMBOL_SRC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGEHLP_SYMBOL_SRC").field("sizeofstruct", &self.sizeofstruct).field("r#type", &self.r#type).field("file", &self.file).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for IMAGEHLP_SYMBOL_SRC {
fn eq(&self, other: &Self) -> bool {
self.sizeofstruct == other.sizeofstruct && self.r#type == other.r#type && self.file == other.file
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for IMAGEHLP_SYMBOL_SRC {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL_SRC {
type Abi = Self;
}
pub const IMAGEHLP_SYMBOL_THUNK: u32 = 8192u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGEHLP_SYMBOL_TYPE_INFO(pub i32);
pub const TI_GET_SYMTAG: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(0i32);
pub const TI_GET_SYMNAME: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(1i32);
pub const TI_GET_LENGTH: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(2i32);
pub const TI_GET_TYPE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(3i32);
pub const TI_GET_TYPEID: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(4i32);
pub const TI_GET_BASETYPE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(5i32);
pub const TI_GET_ARRAYINDEXTYPEID: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(6i32);
pub const TI_FINDCHILDREN: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(7i32);
pub const TI_GET_DATAKIND: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(8i32);
pub const TI_GET_ADDRESSOFFSET: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(9i32);
pub const TI_GET_OFFSET: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(10i32);
pub const TI_GET_VALUE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(11i32);
pub const TI_GET_COUNT: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(12i32);
pub const TI_GET_CHILDRENCOUNT: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(13i32);
pub const TI_GET_BITPOSITION: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(14i32);
pub const TI_GET_VIRTUALBASECLASS: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(15i32);
pub const TI_GET_VIRTUALTABLESHAPEID: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(16i32);
pub const TI_GET_VIRTUALBASEPOINTEROFFSET: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(17i32);
pub const TI_GET_CLASSPARENTID: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(18i32);
pub const TI_GET_NESTED: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(19i32);
pub const TI_GET_SYMINDEX: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(20i32);
pub const TI_GET_LEXICALPARENT: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(21i32);
pub const TI_GET_ADDRESS: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(22i32);
pub const TI_GET_THISADJUST: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(23i32);
pub const TI_GET_UDTKIND: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(24i32);
pub const TI_IS_EQUIV_TO: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(25i32);
pub const TI_GET_CALLING_CONVENTION: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(26i32);
pub const TI_IS_CLOSE_EQUIV_TO: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(27i32);
pub const TI_GTIEX_REQS_VALID: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(28i32);
pub const TI_GET_VIRTUALBASEOFFSET: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(29i32);
pub const TI_GET_VIRTUALBASEDISPINDEX: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(30i32);
pub const TI_GET_IS_REFERENCE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(31i32);
pub const TI_GET_INDIRECTVIRTUALBASECLASS: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(32i32);
pub const TI_GET_VIRTUALBASETABLETYPE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(33i32);
pub const TI_GET_OBJECTPOINTERTYPE: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(34i32);
pub const IMAGEHLP_SYMBOL_TYPE_INFO_MAX: IMAGEHLP_SYMBOL_TYPE_INFO = IMAGEHLP_SYMBOL_TYPE_INFO(35i32);
impl ::core::convert::From<i32> for IMAGEHLP_SYMBOL_TYPE_INFO {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGEHLP_SYMBOL_TYPE_INFO {
type Abi = Self;
}
pub const IMAGEHLP_SYMBOL_VIRTUAL: u32 = 4096u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
pub BeginAddress: u32,
pub Anonymous: IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0,
}
impl IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {}
impl ::core::default::Default for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {}
unsafe impl ::windows::core::Abi for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {
pub UnwindData: u32,
pub Anonymous: IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0,
}
impl IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {}
impl ::core::default::Default for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {}
unsafe impl ::windows::core::Abi for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {
pub _bitfield: u32,
}
impl IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {}
impl ::core::default::Default for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {}
unsafe impl ::windows::core::Abi for IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_COFF_SYMBOLS_HEADER {
pub NumberOfSymbols: u32,
pub LvaToFirstSymbol: u32,
pub NumberOfLinenumbers: u32,
pub LvaToFirstLinenumber: u32,
pub RvaToFirstByteOfCode: u32,
pub RvaToLastByteOfCode: u32,
pub RvaToFirstByteOfData: u32,
pub RvaToLastByteOfData: u32,
}
impl IMAGE_COFF_SYMBOLS_HEADER {}
impl ::core::default::Default for IMAGE_COFF_SYMBOLS_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_COFF_SYMBOLS_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_COFF_SYMBOLS_HEADER")
.field("NumberOfSymbols", &self.NumberOfSymbols)
.field("LvaToFirstSymbol", &self.LvaToFirstSymbol)
.field("NumberOfLinenumbers", &self.NumberOfLinenumbers)
.field("LvaToFirstLinenumber", &self.LvaToFirstLinenumber)
.field("RvaToFirstByteOfCode", &self.RvaToFirstByteOfCode)
.field("RvaToLastByteOfCode", &self.RvaToLastByteOfCode)
.field("RvaToFirstByteOfData", &self.RvaToFirstByteOfData)
.field("RvaToLastByteOfData", &self.RvaToLastByteOfData)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_COFF_SYMBOLS_HEADER {
fn eq(&self, other: &Self) -> bool {
self.NumberOfSymbols == other.NumberOfSymbols && self.LvaToFirstSymbol == other.LvaToFirstSymbol && self.NumberOfLinenumbers == other.NumberOfLinenumbers && self.LvaToFirstLinenumber == other.LvaToFirstLinenumber && self.RvaToFirstByteOfCode == other.RvaToFirstByteOfCode && self.RvaToLastByteOfCode == other.RvaToLastByteOfCode && self.RvaToFirstByteOfData == other.RvaToFirstByteOfData && self.RvaToLastByteOfData == other.RvaToLastByteOfData
}
}
impl ::core::cmp::Eq for IMAGE_COFF_SYMBOLS_HEADER {}
unsafe impl ::windows::core::Abi for IMAGE_COFF_SYMBOLS_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_COR20_HEADER {
pub cb: u32,
pub MajorRuntimeVersion: u16,
pub MinorRuntimeVersion: u16,
pub MetaData: IMAGE_DATA_DIRECTORY,
pub Flags: u32,
pub Anonymous: IMAGE_COR20_HEADER_0,
pub Resources: IMAGE_DATA_DIRECTORY,
pub StrongNameSignature: IMAGE_DATA_DIRECTORY,
pub CodeManagerTable: IMAGE_DATA_DIRECTORY,
pub VTableFixups: IMAGE_DATA_DIRECTORY,
pub ExportAddressTableJumps: IMAGE_DATA_DIRECTORY,
pub ManagedNativeHeader: IMAGE_DATA_DIRECTORY,
}
impl IMAGE_COR20_HEADER {}
impl ::core::default::Default for IMAGE_COR20_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_COR20_HEADER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_COR20_HEADER {}
unsafe impl ::windows::core::Abi for IMAGE_COR20_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union IMAGE_COR20_HEADER_0 {
pub EntryPointToken: u32,
pub EntryPointRVA: u32,
}
impl IMAGE_COR20_HEADER_0 {}
impl ::core::default::Default for IMAGE_COR20_HEADER_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_COR20_HEADER_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_COR20_HEADER_0 {}
unsafe impl ::windows::core::Abi for IMAGE_COR20_HEADER_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_DATA_DIRECTORY {
pub VirtualAddress: u32,
pub Size: u32,
}
impl IMAGE_DATA_DIRECTORY {}
impl ::core::default::Default for IMAGE_DATA_DIRECTORY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_DATA_DIRECTORY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_DATA_DIRECTORY").field("VirtualAddress", &self.VirtualAddress).field("Size", &self.Size).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_DATA_DIRECTORY {
fn eq(&self, other: &Self) -> bool {
self.VirtualAddress == other.VirtualAddress && self.Size == other.Size
}
}
impl ::core::cmp::Eq for IMAGE_DATA_DIRECTORY {}
unsafe impl ::windows::core::Abi for IMAGE_DATA_DIRECTORY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_DEBUG_DIRECTORY {
pub Characteristics: u32,
pub TimeDateStamp: u32,
pub MajorVersion: u16,
pub MinorVersion: u16,
pub Type: IMAGE_DEBUG_TYPE,
pub SizeOfData: u32,
pub AddressOfRawData: u32,
pub PointerToRawData: u32,
}
impl IMAGE_DEBUG_DIRECTORY {}
impl ::core::default::Default for IMAGE_DEBUG_DIRECTORY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_DEBUG_DIRECTORY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_DEBUG_DIRECTORY")
.field("Characteristics", &self.Characteristics)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("MajorVersion", &self.MajorVersion)
.field("MinorVersion", &self.MinorVersion)
.field("Type", &self.Type)
.field("SizeOfData", &self.SizeOfData)
.field("AddressOfRawData", &self.AddressOfRawData)
.field("PointerToRawData", &self.PointerToRawData)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_DEBUG_DIRECTORY {
fn eq(&self, other: &Self) -> bool {
self.Characteristics == other.Characteristics && self.TimeDateStamp == other.TimeDateStamp && self.MajorVersion == other.MajorVersion && self.MinorVersion == other.MinorVersion && self.Type == other.Type && self.SizeOfData == other.SizeOfData && self.AddressOfRawData == other.AddressOfRawData && self.PointerToRawData == other.PointerToRawData
}
}
impl ::core::cmp::Eq for IMAGE_DEBUG_DIRECTORY {}
unsafe impl ::windows::core::Abi for IMAGE_DEBUG_DIRECTORY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct IMAGE_DEBUG_INFORMATION {
pub List: super::super::Kernel::LIST_ENTRY,
pub ReservedSize: u32,
pub ReservedMappedBase: *mut ::core::ffi::c_void,
pub ReservedMachine: u16,
pub ReservedCharacteristics: u16,
pub ReservedCheckSum: u32,
pub ImageBase: u32,
pub SizeOfImage: u32,
pub ReservedNumberOfSections: u32,
pub ReservedSections: *mut IMAGE_SECTION_HEADER,
pub ReservedExportedNamesSize: u32,
pub ReservedExportedNames: super::super::super::Foundation::PSTR,
pub ReservedNumberOfFunctionTableEntries: u32,
pub ReservedFunctionTableEntries: *mut IMAGE_FUNCTION_ENTRY,
pub ReservedLowestFunctionStartingAddress: u32,
pub ReservedHighestFunctionEndingAddress: u32,
pub ReservedNumberOfFpoTableEntries: u32,
pub ReservedFpoTableEntries: *mut FPO_DATA,
pub SizeOfCoffSymbols: u32,
pub CoffSymbols: *mut IMAGE_COFF_SYMBOLS_HEADER,
pub ReservedSizeOfCodeViewSymbols: u32,
pub ReservedCodeViewSymbols: *mut ::core::ffi::c_void,
pub ImageFilePath: super::super::super::Foundation::PSTR,
pub ImageFileName: super::super::super::Foundation::PSTR,
pub ReservedDebugFilePath: super::super::super::Foundation::PSTR,
pub ReservedTimeDateStamp: u32,
pub ReservedRomImage: super::super::super::Foundation::BOOL,
pub ReservedDebugDirectory: *mut IMAGE_DEBUG_DIRECTORY,
pub ReservedNumberOfDebugDirectories: u32,
pub ReservedOriginalFunctionTableBaseAddress: u32,
pub Reserved: [u32; 2],
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl IMAGE_DEBUG_INFORMATION {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for IMAGE_DEBUG_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for IMAGE_DEBUG_INFORMATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_DEBUG_INFORMATION")
.field("List", &self.List)
.field("ReservedSize", &self.ReservedSize)
.field("ReservedMappedBase", &self.ReservedMappedBase)
.field("ReservedMachine", &self.ReservedMachine)
.field("ReservedCharacteristics", &self.ReservedCharacteristics)
.field("ReservedCheckSum", &self.ReservedCheckSum)
.field("ImageBase", &self.ImageBase)
.field("SizeOfImage", &self.SizeOfImage)
.field("ReservedNumberOfSections", &self.ReservedNumberOfSections)
.field("ReservedSections", &self.ReservedSections)
.field("ReservedExportedNamesSize", &self.ReservedExportedNamesSize)
.field("ReservedExportedNames", &self.ReservedExportedNames)
.field("ReservedNumberOfFunctionTableEntries", &self.ReservedNumberOfFunctionTableEntries)
.field("ReservedFunctionTableEntries", &self.ReservedFunctionTableEntries)
.field("ReservedLowestFunctionStartingAddress", &self.ReservedLowestFunctionStartingAddress)
.field("ReservedHighestFunctionEndingAddress", &self.ReservedHighestFunctionEndingAddress)
.field("ReservedNumberOfFpoTableEntries", &self.ReservedNumberOfFpoTableEntries)
.field("ReservedFpoTableEntries", &self.ReservedFpoTableEntries)
.field("SizeOfCoffSymbols", &self.SizeOfCoffSymbols)
.field("CoffSymbols", &self.CoffSymbols)
.field("ReservedSizeOfCodeViewSymbols", &self.ReservedSizeOfCodeViewSymbols)
.field("ReservedCodeViewSymbols", &self.ReservedCodeViewSymbols)
.field("ImageFilePath", &self.ImageFilePath)
.field("ImageFileName", &self.ImageFileName)
.field("ReservedDebugFilePath", &self.ReservedDebugFilePath)
.field("ReservedTimeDateStamp", &self.ReservedTimeDateStamp)
.field("ReservedRomImage", &self.ReservedRomImage)
.field("ReservedDebugDirectory", &self.ReservedDebugDirectory)
.field("ReservedNumberOfDebugDirectories", &self.ReservedNumberOfDebugDirectories)
.field("ReservedOriginalFunctionTableBaseAddress", &self.ReservedOriginalFunctionTableBaseAddress)
.field("Reserved", &self.Reserved)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for IMAGE_DEBUG_INFORMATION {
fn eq(&self, other: &Self) -> bool {
self.List == other.List
&& self.ReservedSize == other.ReservedSize
&& self.ReservedMappedBase == other.ReservedMappedBase
&& self.ReservedMachine == other.ReservedMachine
&& self.ReservedCharacteristics == other.ReservedCharacteristics
&& self.ReservedCheckSum == other.ReservedCheckSum
&& self.ImageBase == other.ImageBase
&& self.SizeOfImage == other.SizeOfImage
&& self.ReservedNumberOfSections == other.ReservedNumberOfSections
&& self.ReservedSections == other.ReservedSections
&& self.ReservedExportedNamesSize == other.ReservedExportedNamesSize
&& self.ReservedExportedNames == other.ReservedExportedNames
&& self.ReservedNumberOfFunctionTableEntries == other.ReservedNumberOfFunctionTableEntries
&& self.ReservedFunctionTableEntries == other.ReservedFunctionTableEntries
&& self.ReservedLowestFunctionStartingAddress == other.ReservedLowestFunctionStartingAddress
&& self.ReservedHighestFunctionEndingAddress == other.ReservedHighestFunctionEndingAddress
&& self.ReservedNumberOfFpoTableEntries == other.ReservedNumberOfFpoTableEntries
&& self.ReservedFpoTableEntries == other.ReservedFpoTableEntries
&& self.SizeOfCoffSymbols == other.SizeOfCoffSymbols
&& self.CoffSymbols == other.CoffSymbols
&& self.ReservedSizeOfCodeViewSymbols == other.ReservedSizeOfCodeViewSymbols
&& self.ReservedCodeViewSymbols == other.ReservedCodeViewSymbols
&& self.ImageFilePath == other.ImageFilePath
&& self.ImageFileName == other.ImageFileName
&& self.ReservedDebugFilePath == other.ReservedDebugFilePath
&& self.ReservedTimeDateStamp == other.ReservedTimeDateStamp
&& self.ReservedRomImage == other.ReservedRomImage
&& self.ReservedDebugDirectory == other.ReservedDebugDirectory
&& self.ReservedNumberOfDebugDirectories == other.ReservedNumberOfDebugDirectories
&& self.ReservedOriginalFunctionTableBaseAddress == other.ReservedOriginalFunctionTableBaseAddress
&& self.Reserved == other.Reserved
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for IMAGE_DEBUG_INFORMATION {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for IMAGE_DEBUG_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_DEBUG_TYPE(pub u32);
pub const IMAGE_DEBUG_TYPE_UNKNOWN: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(0u32);
pub const IMAGE_DEBUG_TYPE_COFF: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(1u32);
pub const IMAGE_DEBUG_TYPE_CODEVIEW: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(2u32);
pub const IMAGE_DEBUG_TYPE_FPO: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(3u32);
pub const IMAGE_DEBUG_TYPE_MISC: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(4u32);
pub const IMAGE_DEBUG_TYPE_EXCEPTION: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(5u32);
pub const IMAGE_DEBUG_TYPE_FIXUP: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(6u32);
pub const IMAGE_DEBUG_TYPE_BORLAND: IMAGE_DEBUG_TYPE = IMAGE_DEBUG_TYPE(9u32);
impl ::core::convert::From<u32> for IMAGE_DEBUG_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_DEBUG_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_DEBUG_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_DEBUG_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_DEBUG_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_DEBUG_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_DEBUG_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_DIRECTORY_ENTRY(pub u32);
pub const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(7u32);
pub const IMAGE_DIRECTORY_ENTRY_BASERELOC: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(5u32);
pub const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(11u32);
pub const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(14u32);
pub const IMAGE_DIRECTORY_ENTRY_DEBUG: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(6u32);
pub const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(13u32);
pub const IMAGE_DIRECTORY_ENTRY_EXCEPTION: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(3u32);
pub const IMAGE_DIRECTORY_ENTRY_EXPORT: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(0u32);
pub const IMAGE_DIRECTORY_ENTRY_GLOBALPTR: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(8u32);
pub const IMAGE_DIRECTORY_ENTRY_IAT: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(12u32);
pub const IMAGE_DIRECTORY_ENTRY_IMPORT: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(1u32);
pub const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(10u32);
pub const IMAGE_DIRECTORY_ENTRY_RESOURCE: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(2u32);
pub const IMAGE_DIRECTORY_ENTRY_SECURITY: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(4u32);
pub const IMAGE_DIRECTORY_ENTRY_TLS: IMAGE_DIRECTORY_ENTRY = IMAGE_DIRECTORY_ENTRY(9u32);
impl ::core::convert::From<u32> for IMAGE_DIRECTORY_ENTRY {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_DIRECTORY_ENTRY {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_DIRECTORY_ENTRY {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_DIRECTORY_ENTRY {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_DIRECTORY_ENTRY {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_DIRECTORY_ENTRY {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_DIRECTORY_ENTRY {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_DLL_CHARACTERISTICS(pub u16);
pub const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(32u16);
pub const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(64u16);
pub const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(128u16);
pub const IMAGE_DLLCHARACTERISTICS_NX_COMPAT: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(256u16);
pub const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(512u16);
pub const IMAGE_DLLCHARACTERISTICS_NO_SEH: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(1024u16);
pub const IMAGE_DLLCHARACTERISTICS_NO_BIND: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(2048u16);
pub const IMAGE_DLLCHARACTERISTICS_APPCONTAINER: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(4096u16);
pub const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(8192u16);
pub const IMAGE_DLLCHARACTERISTICS_GUARD_CF: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(16384u16);
pub const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(32768u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_COMPAT: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(1u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_COMPAT_STRICT_MODE: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(2u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_SET_CONTEXT_IP_VALIDATION_RELAXED_MODE: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(4u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_DYNAMIC_APIS_ALLOW_IN_PROC: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(8u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_RESERVED_1: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(16u16);
pub const IMAGE_DLLCHARACTERISTICS_EX_CET_RESERVED_2: IMAGE_DLL_CHARACTERISTICS = IMAGE_DLL_CHARACTERISTICS(32u16);
impl ::core::convert::From<u16> for IMAGE_DLL_CHARACTERISTICS {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_DLL_CHARACTERISTICS {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_DLL_CHARACTERISTICS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_DLL_CHARACTERISTICS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_DLL_CHARACTERISTICS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_DLL_CHARACTERISTICS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_DLL_CHARACTERISTICS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_FILE_CHARACTERISTICS(pub u16);
pub const IMAGE_FILE_RELOCS_STRIPPED: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(1u16);
pub const IMAGE_FILE_EXECUTABLE_IMAGE: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(2u16);
pub const IMAGE_FILE_LINE_NUMS_STRIPPED: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(4u16);
pub const IMAGE_FILE_LOCAL_SYMS_STRIPPED: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(8u16);
pub const IMAGE_FILE_AGGRESIVE_WS_TRIM: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(16u16);
pub const IMAGE_FILE_LARGE_ADDRESS_AWARE: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(32u16);
pub const IMAGE_FILE_BYTES_REVERSED_LO: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(128u16);
pub const IMAGE_FILE_32BIT_MACHINE: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(256u16);
pub const IMAGE_FILE_DEBUG_STRIPPED: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(512u16);
pub const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(1024u16);
pub const IMAGE_FILE_NET_RUN_FROM_SWAP: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(2048u16);
pub const IMAGE_FILE_SYSTEM: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(4096u16);
pub const IMAGE_FILE_DLL: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(8192u16);
pub const IMAGE_FILE_UP_SYSTEM_ONLY: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(16384u16);
pub const IMAGE_FILE_BYTES_REVERSED_HI: IMAGE_FILE_CHARACTERISTICS = IMAGE_FILE_CHARACTERISTICS(32768u16);
impl ::core::convert::From<u16> for IMAGE_FILE_CHARACTERISTICS {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_FILE_CHARACTERISTICS {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_FILE_CHARACTERISTICS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_FILE_CHARACTERISTICS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_FILE_CHARACTERISTICS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_FILE_CHARACTERISTICS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_FILE_CHARACTERISTICS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_FILE_CHARACTERISTICS2(pub u32);
pub const IMAGE_FILE_RELOCS_STRIPPED2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(1u32);
pub const IMAGE_FILE_EXECUTABLE_IMAGE2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(2u32);
pub const IMAGE_FILE_LINE_NUMS_STRIPPED2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(4u32);
pub const IMAGE_FILE_LOCAL_SYMS_STRIPPED2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(8u32);
pub const IMAGE_FILE_AGGRESIVE_WS_TRIM2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(16u32);
pub const IMAGE_FILE_LARGE_ADDRESS_AWARE2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(32u32);
pub const IMAGE_FILE_BYTES_REVERSED_LO2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(128u32);
pub const IMAGE_FILE_32BIT_MACHINE2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(256u32);
pub const IMAGE_FILE_DEBUG_STRIPPED2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(512u32);
pub const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(1024u32);
pub const IMAGE_FILE_NET_RUN_FROM_SWAP2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(2048u32);
pub const IMAGE_FILE_SYSTEM_2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(4096u32);
pub const IMAGE_FILE_DLL_2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(8192u32);
pub const IMAGE_FILE_UP_SYSTEM_ONLY_2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(16384u32);
pub const IMAGE_FILE_BYTES_REVERSED_HI_2: IMAGE_FILE_CHARACTERISTICS2 = IMAGE_FILE_CHARACTERISTICS2(32768u32);
impl ::core::convert::From<u32> for IMAGE_FILE_CHARACTERISTICS2 {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_FILE_CHARACTERISTICS2 {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_FILE_CHARACTERISTICS2 {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_FILE_CHARACTERISTICS2 {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_FILE_CHARACTERISTICS2 {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_FILE_CHARACTERISTICS2 {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_FILE_CHARACTERISTICS2 {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_FILE_HEADER {
pub Machine: IMAGE_FILE_MACHINE,
pub NumberOfSections: u16,
pub TimeDateStamp: u32,
pub PointerToSymbolTable: u32,
pub NumberOfSymbols: u32,
pub SizeOfOptionalHeader: u16,
pub Characteristics: IMAGE_FILE_CHARACTERISTICS,
}
impl IMAGE_FILE_HEADER {}
impl ::core::default::Default for IMAGE_FILE_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_FILE_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_FILE_HEADER")
.field("Machine", &self.Machine)
.field("NumberOfSections", &self.NumberOfSections)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("PointerToSymbolTable", &self.PointerToSymbolTable)
.field("NumberOfSymbols", &self.NumberOfSymbols)
.field("SizeOfOptionalHeader", &self.SizeOfOptionalHeader)
.field("Characteristics", &self.Characteristics)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_FILE_HEADER {
fn eq(&self, other: &Self) -> bool {
self.Machine == other.Machine && self.NumberOfSections == other.NumberOfSections && self.TimeDateStamp == other.TimeDateStamp && self.PointerToSymbolTable == other.PointerToSymbolTable && self.NumberOfSymbols == other.NumberOfSymbols && self.SizeOfOptionalHeader == other.SizeOfOptionalHeader && self.Characteristics == other.Characteristics
}
}
impl ::core::cmp::Eq for IMAGE_FILE_HEADER {}
unsafe impl ::windows::core::Abi for IMAGE_FILE_HEADER {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_FILE_MACHINE(pub u16);
pub const IMAGE_FILE_MACHINE_AXP64: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(644u16);
pub const IMAGE_FILE_MACHINE_I386: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(332u16);
pub const IMAGE_FILE_MACHINE_IA64: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(512u16);
pub const IMAGE_FILE_MACHINE_AMD64: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(34404u16);
pub const IMAGE_FILE_MACHINE_UNKNOWN: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(0u16);
pub const IMAGE_FILE_MACHINE_TARGET_HOST: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(1u16);
pub const IMAGE_FILE_MACHINE_R3000: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(354u16);
pub const IMAGE_FILE_MACHINE_R4000: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(358u16);
pub const IMAGE_FILE_MACHINE_R10000: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(360u16);
pub const IMAGE_FILE_MACHINE_WCEMIPSV2: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(361u16);
pub const IMAGE_FILE_MACHINE_ALPHA: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(388u16);
pub const IMAGE_FILE_MACHINE_SH3: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(418u16);
pub const IMAGE_FILE_MACHINE_SH3DSP: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(419u16);
pub const IMAGE_FILE_MACHINE_SH3E: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(420u16);
pub const IMAGE_FILE_MACHINE_SH4: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(422u16);
pub const IMAGE_FILE_MACHINE_SH5: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(424u16);
pub const IMAGE_FILE_MACHINE_ARM: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(448u16);
pub const IMAGE_FILE_MACHINE_THUMB: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(450u16);
pub const IMAGE_FILE_MACHINE_ARMNT: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(452u16);
pub const IMAGE_FILE_MACHINE_AM33: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(467u16);
pub const IMAGE_FILE_MACHINE_POWERPC: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(496u16);
pub const IMAGE_FILE_MACHINE_POWERPCFP: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(497u16);
pub const IMAGE_FILE_MACHINE_MIPS16: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(614u16);
pub const IMAGE_FILE_MACHINE_ALPHA64: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(644u16);
pub const IMAGE_FILE_MACHINE_MIPSFPU: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(870u16);
pub const IMAGE_FILE_MACHINE_MIPSFPU16: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(1126u16);
pub const IMAGE_FILE_MACHINE_TRICORE: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(1312u16);
pub const IMAGE_FILE_MACHINE_CEF: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(3311u16);
pub const IMAGE_FILE_MACHINE_EBC: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(3772u16);
pub const IMAGE_FILE_MACHINE_M32R: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(36929u16);
pub const IMAGE_FILE_MACHINE_ARM64: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(43620u16);
pub const IMAGE_FILE_MACHINE_CEE: IMAGE_FILE_MACHINE = IMAGE_FILE_MACHINE(49390u16);
impl ::core::convert::From<u16> for IMAGE_FILE_MACHINE {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_FILE_MACHINE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_FUNCTION_ENTRY {
pub StartingAddress: u32,
pub EndingAddress: u32,
pub EndOfPrologue: u32,
}
impl IMAGE_FUNCTION_ENTRY {}
impl ::core::default::Default for IMAGE_FUNCTION_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_FUNCTION_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_FUNCTION_ENTRY").field("StartingAddress", &self.StartingAddress).field("EndingAddress", &self.EndingAddress).field("EndOfPrologue", &self.EndOfPrologue).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_FUNCTION_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.StartingAddress == other.StartingAddress && self.EndingAddress == other.EndingAddress && self.EndOfPrologue == other.EndOfPrologue
}
}
impl ::core::cmp::Eq for IMAGE_FUNCTION_ENTRY {}
unsafe impl ::windows::core::Abi for IMAGE_FUNCTION_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct IMAGE_FUNCTION_ENTRY64 {
pub StartingAddress: u64,
pub EndingAddress: u64,
pub Anonymous: IMAGE_FUNCTION_ENTRY64_0,
}
impl IMAGE_FUNCTION_ENTRY64 {}
impl ::core::default::Default for IMAGE_FUNCTION_ENTRY64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_FUNCTION_ENTRY64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_FUNCTION_ENTRY64 {}
unsafe impl ::windows::core::Abi for IMAGE_FUNCTION_ENTRY64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub union IMAGE_FUNCTION_ENTRY64_0 {
pub EndOfPrologue: u64,
pub UnwindInfoAddress: u64,
}
impl IMAGE_FUNCTION_ENTRY64_0 {}
impl ::core::default::Default for IMAGE_FUNCTION_ENTRY64_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_FUNCTION_ENTRY64_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_FUNCTION_ENTRY64_0 {}
unsafe impl ::windows::core::Abi for IMAGE_FUNCTION_ENTRY64_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
pub Flags: u16,
pub Catalog: u16,
pub CatalogOffset: u32,
pub Reserved: u32,
}
impl IMAGE_LOAD_CONFIG_CODE_INTEGRITY {}
impl ::core::default::Default for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_LOAD_CONFIG_CODE_INTEGRITY").field("Flags", &self.Flags).field("Catalog", &self.Catalog).field("CatalogOffset", &self.CatalogOffset).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
fn eq(&self, other: &Self) -> bool {
self.Flags == other.Flags && self.Catalog == other.Catalog && self.CatalogOffset == other.CatalogOffset && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {}
unsafe impl ::windows::core::Abi for IMAGE_LOAD_CONFIG_CODE_INTEGRITY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_LOAD_CONFIG_DIRECTORY32 {
pub Size: u32,
pub TimeDateStamp: u32,
pub MajorVersion: u16,
pub MinorVersion: u16,
pub GlobalFlagsClear: u32,
pub GlobalFlagsSet: u32,
pub CriticalSectionDefaultTimeout: u32,
pub DeCommitFreeBlockThreshold: u32,
pub DeCommitTotalFreeThreshold: u32,
pub LockPrefixTable: u32,
pub MaximumAllocationSize: u32,
pub VirtualMemoryThreshold: u32,
pub ProcessHeapFlags: u32,
pub ProcessAffinityMask: u32,
pub CSDVersion: u16,
pub DependentLoadFlags: u16,
pub EditList: u32,
pub SecurityCookie: u32,
pub SEHandlerTable: u32,
pub SEHandlerCount: u32,
pub GuardCFCheckFunctionPointer: u32,
pub GuardCFDispatchFunctionPointer: u32,
pub GuardCFFunctionTable: u32,
pub GuardCFFunctionCount: u32,
pub GuardFlags: u32,
pub CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
pub GuardAddressTakenIatEntryTable: u32,
pub GuardAddressTakenIatEntryCount: u32,
pub GuardLongJumpTargetTable: u32,
pub GuardLongJumpTargetCount: u32,
pub DynamicValueRelocTable: u32,
pub CHPEMetadataPointer: u32,
pub GuardRFFailureRoutine: u32,
pub GuardRFFailureRoutineFunctionPointer: u32,
pub DynamicValueRelocTableOffset: u32,
pub DynamicValueRelocTableSection: u16,
pub Reserved2: u16,
pub GuardRFVerifyStackPointerFunctionPointer: u32,
pub HotPatchTableOffset: u32,
pub Reserved3: u32,
pub EnclaveConfigurationPointer: u32,
pub VolatileMetadataPointer: u32,
pub GuardEHContinuationTable: u32,
pub GuardEHContinuationCount: u32,
pub GuardXFGCheckFunctionPointer: u32,
pub GuardXFGDispatchFunctionPointer: u32,
pub GuardXFGTableDispatchFunctionPointer: u32,
pub CastGuardOsDeterminedFailureMode: u32,
}
impl IMAGE_LOAD_CONFIG_DIRECTORY32 {}
impl ::core::default::Default for IMAGE_LOAD_CONFIG_DIRECTORY32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_LOAD_CONFIG_DIRECTORY32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_LOAD_CONFIG_DIRECTORY32")
.field("Size", &self.Size)
.field("TimeDateStamp", &self.TimeDateStamp)
.field("MajorVersion", &self.MajorVersion)
.field("MinorVersion", &self.MinorVersion)
.field("GlobalFlagsClear", &self.GlobalFlagsClear)
.field("GlobalFlagsSet", &self.GlobalFlagsSet)
.field("CriticalSectionDefaultTimeout", &self.CriticalSectionDefaultTimeout)
.field("DeCommitFreeBlockThreshold", &self.DeCommitFreeBlockThreshold)
.field("DeCommitTotalFreeThreshold", &self.DeCommitTotalFreeThreshold)
.field("LockPrefixTable", &self.LockPrefixTable)
.field("MaximumAllocationSize", &self.MaximumAllocationSize)
.field("VirtualMemoryThreshold", &self.VirtualMemoryThreshold)
.field("ProcessHeapFlags", &self.ProcessHeapFlags)
.field("ProcessAffinityMask", &self.ProcessAffinityMask)
.field("CSDVersion", &self.CSDVersion)
.field("DependentLoadFlags", &self.DependentLoadFlags)
.field("EditList", &self.EditList)
.field("SecurityCookie", &self.SecurityCookie)
.field("SEHandlerTable", &self.SEHandlerTable)
.field("SEHandlerCount", &self.SEHandlerCount)
.field("GuardCFCheckFunctionPointer", &self.GuardCFCheckFunctionPointer)
.field("GuardCFDispatchFunctionPointer", &self.GuardCFDispatchFunctionPointer)
.field("GuardCFFunctionTable", &self.GuardCFFunctionTable)
.field("GuardCFFunctionCount", &self.GuardCFFunctionCount)
.field("GuardFlags", &self.GuardFlags)
.field("CodeIntegrity", &self.CodeIntegrity)
.field("GuardAddressTakenIatEntryTable", &self.GuardAddressTakenIatEntryTable)
.field("GuardAddressTakenIatEntryCount", &self.GuardAddressTakenIatEntryCount)
.field("GuardLongJumpTargetTable", &self.GuardLongJumpTargetTable)
.field("GuardLongJumpTargetCount", &self.GuardLongJumpTargetCount)
.field("DynamicValueRelocTable", &self.DynamicValueRelocTable)
.field("CHPEMetadataPointer", &self.CHPEMetadataPointer)
.field("GuardRFFailureRoutine", &self.GuardRFFailureRoutine)
.field("GuardRFFailureRoutineFunctionPointer", &self.GuardRFFailureRoutineFunctionPointer)
.field("DynamicValueRelocTableOffset", &self.DynamicValueRelocTableOffset)
.field("DynamicValueRelocTableSection", &self.DynamicValueRelocTableSection)
.field("Reserved2", &self.Reserved2)
.field("GuardRFVerifyStackPointerFunctionPointer", &self.GuardRFVerifyStackPointerFunctionPointer)
.field("HotPatchTableOffset", &self.HotPatchTableOffset)
.field("Reserved3", &self.Reserved3)
.field("EnclaveConfigurationPointer", &self.EnclaveConfigurationPointer)
.field("VolatileMetadataPointer", &self.VolatileMetadataPointer)
.field("GuardEHContinuationTable", &self.GuardEHContinuationTable)
.field("GuardEHContinuationCount", &self.GuardEHContinuationCount)
.field("GuardXFGCheckFunctionPointer", &self.GuardXFGCheckFunctionPointer)
.field("GuardXFGDispatchFunctionPointer", &self.GuardXFGDispatchFunctionPointer)
.field("GuardXFGTableDispatchFunctionPointer", &self.GuardXFGTableDispatchFunctionPointer)
.field("CastGuardOsDeterminedFailureMode", &self.CastGuardOsDeterminedFailureMode)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_LOAD_CONFIG_DIRECTORY32 {
fn eq(&self, other: &Self) -> bool {
self.Size == other.Size
&& self.TimeDateStamp == other.TimeDateStamp
&& self.MajorVersion == other.MajorVersion
&& self.MinorVersion == other.MinorVersion
&& self.GlobalFlagsClear == other.GlobalFlagsClear
&& self.GlobalFlagsSet == other.GlobalFlagsSet
&& self.CriticalSectionDefaultTimeout == other.CriticalSectionDefaultTimeout
&& self.DeCommitFreeBlockThreshold == other.DeCommitFreeBlockThreshold
&& self.DeCommitTotalFreeThreshold == other.DeCommitTotalFreeThreshold
&& self.LockPrefixTable == other.LockPrefixTable
&& self.MaximumAllocationSize == other.MaximumAllocationSize
&& self.VirtualMemoryThreshold == other.VirtualMemoryThreshold
&& self.ProcessHeapFlags == other.ProcessHeapFlags
&& self.ProcessAffinityMask == other.ProcessAffinityMask
&& self.CSDVersion == other.CSDVersion
&& self.DependentLoadFlags == other.DependentLoadFlags
&& self.EditList == other.EditList
&& self.SecurityCookie == other.SecurityCookie
&& self.SEHandlerTable == other.SEHandlerTable
&& self.SEHandlerCount == other.SEHandlerCount
&& self.GuardCFCheckFunctionPointer == other.GuardCFCheckFunctionPointer
&& self.GuardCFDispatchFunctionPointer == other.GuardCFDispatchFunctionPointer
&& self.GuardCFFunctionTable == other.GuardCFFunctionTable
&& self.GuardCFFunctionCount == other.GuardCFFunctionCount
&& self.GuardFlags == other.GuardFlags
&& self.CodeIntegrity == other.CodeIntegrity
&& self.GuardAddressTakenIatEntryTable == other.GuardAddressTakenIatEntryTable
&& self.GuardAddressTakenIatEntryCount == other.GuardAddressTakenIatEntryCount
&& self.GuardLongJumpTargetTable == other.GuardLongJumpTargetTable
&& self.GuardLongJumpTargetCount == other.GuardLongJumpTargetCount
&& self.DynamicValueRelocTable == other.DynamicValueRelocTable
&& self.CHPEMetadataPointer == other.CHPEMetadataPointer
&& self.GuardRFFailureRoutine == other.GuardRFFailureRoutine
&& self.GuardRFFailureRoutineFunctionPointer == other.GuardRFFailureRoutineFunctionPointer
&& self.DynamicValueRelocTableOffset == other.DynamicValueRelocTableOffset
&& self.DynamicValueRelocTableSection == other.DynamicValueRelocTableSection
&& self.Reserved2 == other.Reserved2
&& self.GuardRFVerifyStackPointerFunctionPointer == other.GuardRFVerifyStackPointerFunctionPointer
&& self.HotPatchTableOffset == other.HotPatchTableOffset
&& self.Reserved3 == other.Reserved3
&& self.EnclaveConfigurationPointer == other.EnclaveConfigurationPointer
&& self.VolatileMetadataPointer == other.VolatileMetadataPointer
&& self.GuardEHContinuationTable == other.GuardEHContinuationTable
&& self.GuardEHContinuationCount == other.GuardEHContinuationCount
&& self.GuardXFGCheckFunctionPointer == other.GuardXFGCheckFunctionPointer
&& self.GuardXFGDispatchFunctionPointer == other.GuardXFGDispatchFunctionPointer
&& self.GuardXFGTableDispatchFunctionPointer == other.GuardXFGTableDispatchFunctionPointer
&& self.CastGuardOsDeterminedFailureMode == other.CastGuardOsDeterminedFailureMode
}
}
impl ::core::cmp::Eq for IMAGE_LOAD_CONFIG_DIRECTORY32 {}
unsafe impl ::windows::core::Abi for IMAGE_LOAD_CONFIG_DIRECTORY32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct IMAGE_LOAD_CONFIG_DIRECTORY64 {
pub Size: u32,
pub TimeDateStamp: u32,
pub MajorVersion: u16,
pub MinorVersion: u16,
pub GlobalFlagsClear: u32,
pub GlobalFlagsSet: u32,
pub CriticalSectionDefaultTimeout: u32,
pub DeCommitFreeBlockThreshold: u64,
pub DeCommitTotalFreeThreshold: u64,
pub LockPrefixTable: u64,
pub MaximumAllocationSize: u64,
pub VirtualMemoryThreshold: u64,
pub ProcessAffinityMask: u64,
pub ProcessHeapFlags: u32,
pub CSDVersion: u16,
pub DependentLoadFlags: u16,
pub EditList: u64,
pub SecurityCookie: u64,
pub SEHandlerTable: u64,
pub SEHandlerCount: u64,
pub GuardCFCheckFunctionPointer: u64,
pub GuardCFDispatchFunctionPointer: u64,
pub GuardCFFunctionTable: u64,
pub GuardCFFunctionCount: u64,
pub GuardFlags: u32,
pub CodeIntegrity: IMAGE_LOAD_CONFIG_CODE_INTEGRITY,
pub GuardAddressTakenIatEntryTable: u64,
pub GuardAddressTakenIatEntryCount: u64,
pub GuardLongJumpTargetTable: u64,
pub GuardLongJumpTargetCount: u64,
pub DynamicValueRelocTable: u64,
pub CHPEMetadataPointer: u64,
pub GuardRFFailureRoutine: u64,
pub GuardRFFailureRoutineFunctionPointer: u64,
pub DynamicValueRelocTableOffset: u32,
pub DynamicValueRelocTableSection: u16,
pub Reserved2: u16,
pub GuardRFVerifyStackPointerFunctionPointer: u64,
pub HotPatchTableOffset: u32,
pub Reserved3: u32,
pub EnclaveConfigurationPointer: u64,
pub VolatileMetadataPointer: u64,
pub GuardEHContinuationTable: u64,
pub GuardEHContinuationCount: u64,
pub GuardXFGCheckFunctionPointer: u64,
pub GuardXFGDispatchFunctionPointer: u64,
pub GuardXFGTableDispatchFunctionPointer: u64,
pub CastGuardOsDeterminedFailureMode: u64,
}
impl IMAGE_LOAD_CONFIG_DIRECTORY64 {}
impl ::core::default::Default for IMAGE_LOAD_CONFIG_DIRECTORY64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_LOAD_CONFIG_DIRECTORY64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_LOAD_CONFIG_DIRECTORY64 {}
unsafe impl ::windows::core::Abi for IMAGE_LOAD_CONFIG_DIRECTORY64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_NT_HEADERS32 {
pub Signature: u32,
pub FileHeader: IMAGE_FILE_HEADER,
pub OptionalHeader: IMAGE_OPTIONAL_HEADER32,
}
impl IMAGE_NT_HEADERS32 {}
impl ::core::default::Default for IMAGE_NT_HEADERS32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_NT_HEADERS32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_NT_HEADERS32").field("Signature", &self.Signature).field("FileHeader", &self.FileHeader).field("OptionalHeader", &self.OptionalHeader).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_NT_HEADERS32 {
fn eq(&self, other: &Self) -> bool {
self.Signature == other.Signature && self.FileHeader == other.FileHeader && self.OptionalHeader == other.OptionalHeader
}
}
impl ::core::cmp::Eq for IMAGE_NT_HEADERS32 {}
unsafe impl ::windows::core::Abi for IMAGE_NT_HEADERS32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_NT_HEADERS64 {
pub Signature: u32,
pub FileHeader: IMAGE_FILE_HEADER,
pub OptionalHeader: IMAGE_OPTIONAL_HEADER64,
}
impl IMAGE_NT_HEADERS64 {}
impl ::core::default::Default for IMAGE_NT_HEADERS64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_NT_HEADERS64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_NT_HEADERS64 {}
unsafe impl ::windows::core::Abi for IMAGE_NT_HEADERS64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_OPTIONAL_HEADER32 {
pub Magic: IMAGE_OPTIONAL_HEADER_MAGIC,
pub MajorLinkerVersion: u8,
pub MinorLinkerVersion: u8,
pub SizeOfCode: u32,
pub SizeOfInitializedData: u32,
pub SizeOfUninitializedData: u32,
pub AddressOfEntryPoint: u32,
pub BaseOfCode: u32,
pub BaseOfData: u32,
pub ImageBase: u32,
pub SectionAlignment: u32,
pub FileAlignment: u32,
pub MajorOperatingSystemVersion: u16,
pub MinorOperatingSystemVersion: u16,
pub MajorImageVersion: u16,
pub MinorImageVersion: u16,
pub MajorSubsystemVersion: u16,
pub MinorSubsystemVersion: u16,
pub Win32VersionValue: u32,
pub SizeOfImage: u32,
pub SizeOfHeaders: u32,
pub CheckSum: u32,
pub Subsystem: IMAGE_SUBSYSTEM,
pub DllCharacteristics: IMAGE_DLL_CHARACTERISTICS,
pub SizeOfStackReserve: u32,
pub SizeOfStackCommit: u32,
pub SizeOfHeapReserve: u32,
pub SizeOfHeapCommit: u32,
pub LoaderFlags: u32,
pub NumberOfRvaAndSizes: u32,
pub DataDirectory: [IMAGE_DATA_DIRECTORY; 16],
}
impl IMAGE_OPTIONAL_HEADER32 {}
impl ::core::default::Default for IMAGE_OPTIONAL_HEADER32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_OPTIONAL_HEADER32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_OPTIONAL_HEADER32")
.field("Magic", &self.Magic)
.field("MajorLinkerVersion", &self.MajorLinkerVersion)
.field("MinorLinkerVersion", &self.MinorLinkerVersion)
.field("SizeOfCode", &self.SizeOfCode)
.field("SizeOfInitializedData", &self.SizeOfInitializedData)
.field("SizeOfUninitializedData", &self.SizeOfUninitializedData)
.field("AddressOfEntryPoint", &self.AddressOfEntryPoint)
.field("BaseOfCode", &self.BaseOfCode)
.field("BaseOfData", &self.BaseOfData)
.field("ImageBase", &self.ImageBase)
.field("SectionAlignment", &self.SectionAlignment)
.field("FileAlignment", &self.FileAlignment)
.field("MajorOperatingSystemVersion", &self.MajorOperatingSystemVersion)
.field("MinorOperatingSystemVersion", &self.MinorOperatingSystemVersion)
.field("MajorImageVersion", &self.MajorImageVersion)
.field("MinorImageVersion", &self.MinorImageVersion)
.field("MajorSubsystemVersion", &self.MajorSubsystemVersion)
.field("MinorSubsystemVersion", &self.MinorSubsystemVersion)
.field("Win32VersionValue", &self.Win32VersionValue)
.field("SizeOfImage", &self.SizeOfImage)
.field("SizeOfHeaders", &self.SizeOfHeaders)
.field("CheckSum", &self.CheckSum)
.field("Subsystem", &self.Subsystem)
.field("DllCharacteristics", &self.DllCharacteristics)
.field("SizeOfStackReserve", &self.SizeOfStackReserve)
.field("SizeOfStackCommit", &self.SizeOfStackCommit)
.field("SizeOfHeapReserve", &self.SizeOfHeapReserve)
.field("SizeOfHeapCommit", &self.SizeOfHeapCommit)
.field("LoaderFlags", &self.LoaderFlags)
.field("NumberOfRvaAndSizes", &self.NumberOfRvaAndSizes)
.field("DataDirectory", &self.DataDirectory)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_OPTIONAL_HEADER32 {
fn eq(&self, other: &Self) -> bool {
self.Magic == other.Magic
&& self.MajorLinkerVersion == other.MajorLinkerVersion
&& self.MinorLinkerVersion == other.MinorLinkerVersion
&& self.SizeOfCode == other.SizeOfCode
&& self.SizeOfInitializedData == other.SizeOfInitializedData
&& self.SizeOfUninitializedData == other.SizeOfUninitializedData
&& self.AddressOfEntryPoint == other.AddressOfEntryPoint
&& self.BaseOfCode == other.BaseOfCode
&& self.BaseOfData == other.BaseOfData
&& self.ImageBase == other.ImageBase
&& self.SectionAlignment == other.SectionAlignment
&& self.FileAlignment == other.FileAlignment
&& self.MajorOperatingSystemVersion == other.MajorOperatingSystemVersion
&& self.MinorOperatingSystemVersion == other.MinorOperatingSystemVersion
&& self.MajorImageVersion == other.MajorImageVersion
&& self.MinorImageVersion == other.MinorImageVersion
&& self.MajorSubsystemVersion == other.MajorSubsystemVersion
&& self.MinorSubsystemVersion == other.MinorSubsystemVersion
&& self.Win32VersionValue == other.Win32VersionValue
&& self.SizeOfImage == other.SizeOfImage
&& self.SizeOfHeaders == other.SizeOfHeaders
&& self.CheckSum == other.CheckSum
&& self.Subsystem == other.Subsystem
&& self.DllCharacteristics == other.DllCharacteristics
&& self.SizeOfStackReserve == other.SizeOfStackReserve
&& self.SizeOfStackCommit == other.SizeOfStackCommit
&& self.SizeOfHeapReserve == other.SizeOfHeapReserve
&& self.SizeOfHeapCommit == other.SizeOfHeapCommit
&& self.LoaderFlags == other.LoaderFlags
&& self.NumberOfRvaAndSizes == other.NumberOfRvaAndSizes
&& self.DataDirectory == other.DataDirectory
}
}
impl ::core::cmp::Eq for IMAGE_OPTIONAL_HEADER32 {}
unsafe impl ::windows::core::Abi for IMAGE_OPTIONAL_HEADER32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct IMAGE_OPTIONAL_HEADER64 {
pub Magic: IMAGE_OPTIONAL_HEADER_MAGIC,
pub MajorLinkerVersion: u8,
pub MinorLinkerVersion: u8,
pub SizeOfCode: u32,
pub SizeOfInitializedData: u32,
pub SizeOfUninitializedData: u32,
pub AddressOfEntryPoint: u32,
pub BaseOfCode: u32,
pub ImageBase: u64,
pub SectionAlignment: u32,
pub FileAlignment: u32,
pub MajorOperatingSystemVersion: u16,
pub MinorOperatingSystemVersion: u16,
pub MajorImageVersion: u16,
pub MinorImageVersion: u16,
pub MajorSubsystemVersion: u16,
pub MinorSubsystemVersion: u16,
pub Win32VersionValue: u32,
pub SizeOfImage: u32,
pub SizeOfHeaders: u32,
pub CheckSum: u32,
pub Subsystem: IMAGE_SUBSYSTEM,
pub DllCharacteristics: IMAGE_DLL_CHARACTERISTICS,
pub SizeOfStackReserve: u64,
pub SizeOfStackCommit: u64,
pub SizeOfHeapReserve: u64,
pub SizeOfHeapCommit: u64,
pub LoaderFlags: u32,
pub NumberOfRvaAndSizes: u32,
pub DataDirectory: [IMAGE_DATA_DIRECTORY; 16],
}
impl IMAGE_OPTIONAL_HEADER64 {}
impl ::core::default::Default for IMAGE_OPTIONAL_HEADER64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_OPTIONAL_HEADER64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_OPTIONAL_HEADER64 {}
unsafe impl ::windows::core::Abi for IMAGE_OPTIONAL_HEADER64 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_OPTIONAL_HEADER_MAGIC(pub u16);
pub const IMAGE_NT_OPTIONAL_HDR_MAGIC: IMAGE_OPTIONAL_HEADER_MAGIC = IMAGE_OPTIONAL_HEADER_MAGIC(523u16);
pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC: IMAGE_OPTIONAL_HEADER_MAGIC = IMAGE_OPTIONAL_HEADER_MAGIC(267u16);
pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC: IMAGE_OPTIONAL_HEADER_MAGIC = IMAGE_OPTIONAL_HEADER_MAGIC(523u16);
pub const IMAGE_ROM_OPTIONAL_HDR_MAGIC: IMAGE_OPTIONAL_HEADER_MAGIC = IMAGE_OPTIONAL_HEADER_MAGIC(263u16);
impl ::core::convert::From<u16> for IMAGE_OPTIONAL_HEADER_MAGIC {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_OPTIONAL_HEADER_MAGIC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_ROM_HEADERS {
pub FileHeader: IMAGE_FILE_HEADER,
pub OptionalHeader: IMAGE_ROM_OPTIONAL_HEADER,
}
impl IMAGE_ROM_HEADERS {}
impl ::core::default::Default for IMAGE_ROM_HEADERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_ROM_HEADERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_ROM_HEADERS").field("FileHeader", &self.FileHeader).field("OptionalHeader", &self.OptionalHeader).finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_ROM_HEADERS {
fn eq(&self, other: &Self) -> bool {
self.FileHeader == other.FileHeader && self.OptionalHeader == other.OptionalHeader
}
}
impl ::core::cmp::Eq for IMAGE_ROM_HEADERS {}
unsafe impl ::windows::core::Abi for IMAGE_ROM_HEADERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_ROM_OPTIONAL_HEADER {
pub Magic: u16,
pub MajorLinkerVersion: u8,
pub MinorLinkerVersion: u8,
pub SizeOfCode: u32,
pub SizeOfInitializedData: u32,
pub SizeOfUninitializedData: u32,
pub AddressOfEntryPoint: u32,
pub BaseOfCode: u32,
pub BaseOfData: u32,
pub BaseOfBss: u32,
pub GprMask: u32,
pub CprMask: [u32; 4],
pub GpValue: u32,
}
impl IMAGE_ROM_OPTIONAL_HEADER {}
impl ::core::default::Default for IMAGE_ROM_OPTIONAL_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IMAGE_ROM_OPTIONAL_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IMAGE_ROM_OPTIONAL_HEADER")
.field("Magic", &self.Magic)
.field("MajorLinkerVersion", &self.MajorLinkerVersion)
.field("MinorLinkerVersion", &self.MinorLinkerVersion)
.field("SizeOfCode", &self.SizeOfCode)
.field("SizeOfInitializedData", &self.SizeOfInitializedData)
.field("SizeOfUninitializedData", &self.SizeOfUninitializedData)
.field("AddressOfEntryPoint", &self.AddressOfEntryPoint)
.field("BaseOfCode", &self.BaseOfCode)
.field("BaseOfData", &self.BaseOfData)
.field("BaseOfBss", &self.BaseOfBss)
.field("GprMask", &self.GprMask)
.field("CprMask", &self.CprMask)
.field("GpValue", &self.GpValue)
.finish()
}
}
impl ::core::cmp::PartialEq for IMAGE_ROM_OPTIONAL_HEADER {
fn eq(&self, other: &Self) -> bool {
self.Magic == other.Magic
&& self.MajorLinkerVersion == other.MajorLinkerVersion
&& self.MinorLinkerVersion == other.MinorLinkerVersion
&& self.SizeOfCode == other.SizeOfCode
&& self.SizeOfInitializedData == other.SizeOfInitializedData
&& self.SizeOfUninitializedData == other.SizeOfUninitializedData
&& self.AddressOfEntryPoint == other.AddressOfEntryPoint
&& self.BaseOfCode == other.BaseOfCode
&& self.BaseOfData == other.BaseOfData
&& self.BaseOfBss == other.BaseOfBss
&& self.GprMask == other.GprMask
&& self.CprMask == other.CprMask
&& self.GpValue == other.GpValue
}
}
impl ::core::cmp::Eq for IMAGE_ROM_OPTIONAL_HEADER {}
unsafe impl ::windows::core::Abi for IMAGE_ROM_OPTIONAL_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_RUNTIME_FUNCTION_ENTRY {
pub BeginAddress: u32,
pub EndAddress: u32,
pub Anonymous: IMAGE_RUNTIME_FUNCTION_ENTRY_0,
}
impl IMAGE_RUNTIME_FUNCTION_ENTRY {}
impl ::core::default::Default for IMAGE_RUNTIME_FUNCTION_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_RUNTIME_FUNCTION_ENTRY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_RUNTIME_FUNCTION_ENTRY {}
unsafe impl ::windows::core::Abi for IMAGE_RUNTIME_FUNCTION_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union IMAGE_RUNTIME_FUNCTION_ENTRY_0 {
pub UnwindInfoAddress: u32,
pub UnwindData: u32,
}
impl IMAGE_RUNTIME_FUNCTION_ENTRY_0 {}
impl ::core::default::Default for IMAGE_RUNTIME_FUNCTION_ENTRY_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_RUNTIME_FUNCTION_ENTRY_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_RUNTIME_FUNCTION_ENTRY_0 {}
unsafe impl ::windows::core::Abi for IMAGE_RUNTIME_FUNCTION_ENTRY_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_SECTION_CHARACTERISTICS(pub u32);
pub const IMAGE_SCN_TYPE_NO_PAD: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(8u32);
pub const IMAGE_SCN_CNT_CODE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(32u32);
pub const IMAGE_SCN_CNT_INITIALIZED_DATA: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(64u32);
pub const IMAGE_SCN_CNT_UNINITIALIZED_DATA: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(128u32);
pub const IMAGE_SCN_LNK_OTHER: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(256u32);
pub const IMAGE_SCN_LNK_INFO: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(512u32);
pub const IMAGE_SCN_LNK_REMOVE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(2048u32);
pub const IMAGE_SCN_LNK_COMDAT: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(4096u32);
pub const IMAGE_SCN_NO_DEFER_SPEC_EXC: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(16384u32);
pub const IMAGE_SCN_GPREL: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(32768u32);
pub const IMAGE_SCN_MEM_FARDATA: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(32768u32);
pub const IMAGE_SCN_MEM_PURGEABLE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(131072u32);
pub const IMAGE_SCN_MEM_16BIT: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(131072u32);
pub const IMAGE_SCN_MEM_LOCKED: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(262144u32);
pub const IMAGE_SCN_MEM_PRELOAD: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(524288u32);
pub const IMAGE_SCN_ALIGN_1BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(1048576u32);
pub const IMAGE_SCN_ALIGN_2BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(2097152u32);
pub const IMAGE_SCN_ALIGN_4BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(3145728u32);
pub const IMAGE_SCN_ALIGN_8BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(4194304u32);
pub const IMAGE_SCN_ALIGN_16BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(5242880u32);
pub const IMAGE_SCN_ALIGN_32BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(6291456u32);
pub const IMAGE_SCN_ALIGN_64BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(7340032u32);
pub const IMAGE_SCN_ALIGN_128BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(8388608u32);
pub const IMAGE_SCN_ALIGN_256BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(9437184u32);
pub const IMAGE_SCN_ALIGN_512BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(10485760u32);
pub const IMAGE_SCN_ALIGN_1024BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(11534336u32);
pub const IMAGE_SCN_ALIGN_2048BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(12582912u32);
pub const IMAGE_SCN_ALIGN_4096BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(13631488u32);
pub const IMAGE_SCN_ALIGN_8192BYTES: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(14680064u32);
pub const IMAGE_SCN_ALIGN_MASK: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(15728640u32);
pub const IMAGE_SCN_LNK_NRELOC_OVFL: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(16777216u32);
pub const IMAGE_SCN_MEM_DISCARDABLE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(33554432u32);
pub const IMAGE_SCN_MEM_NOT_CACHED: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(67108864u32);
pub const IMAGE_SCN_MEM_NOT_PAGED: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(134217728u32);
pub const IMAGE_SCN_MEM_SHARED: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(268435456u32);
pub const IMAGE_SCN_MEM_EXECUTE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(536870912u32);
pub const IMAGE_SCN_MEM_READ: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(1073741824u32);
pub const IMAGE_SCN_MEM_WRITE: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(2147483648u32);
pub const IMAGE_SCN_SCALE_INDEX: IMAGE_SECTION_CHARACTERISTICS = IMAGE_SECTION_CHARACTERISTICS(1u32);
impl ::core::convert::From<u32> for IMAGE_SECTION_CHARACTERISTICS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_SECTION_CHARACTERISTICS {
type Abi = Self;
}
impl ::core::ops::BitOr for IMAGE_SECTION_CHARACTERISTICS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for IMAGE_SECTION_CHARACTERISTICS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for IMAGE_SECTION_CHARACTERISTICS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for IMAGE_SECTION_CHARACTERISTICS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for IMAGE_SECTION_CHARACTERISTICS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IMAGE_SECTION_HEADER {
pub Name: [u8; 8],
pub Misc: IMAGE_SECTION_HEADER_0,
pub VirtualAddress: u32,
pub SizeOfRawData: u32,
pub PointerToRawData: u32,
pub PointerToRelocations: u32,
pub PointerToLinenumbers: u32,
pub NumberOfRelocations: u16,
pub NumberOfLinenumbers: u16,
pub Characteristics: IMAGE_SECTION_CHARACTERISTICS,
}
impl IMAGE_SECTION_HEADER {}
impl ::core::default::Default for IMAGE_SECTION_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_SECTION_HEADER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_SECTION_HEADER {}
unsafe impl ::windows::core::Abi for IMAGE_SECTION_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union IMAGE_SECTION_HEADER_0 {
pub PhysicalAddress: u32,
pub VirtualSize: u32,
}
impl IMAGE_SECTION_HEADER_0 {}
impl ::core::default::Default for IMAGE_SECTION_HEADER_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IMAGE_SECTION_HEADER_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IMAGE_SECTION_HEADER_0 {}
unsafe impl ::windows::core::Abi for IMAGE_SECTION_HEADER_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IMAGE_SUBSYSTEM(pub u16);
pub const IMAGE_SUBSYSTEM_UNKNOWN: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(0u16);
pub const IMAGE_SUBSYSTEM_NATIVE: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(1u16);
pub const IMAGE_SUBSYSTEM_WINDOWS_GUI: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(2u16);
pub const IMAGE_SUBSYSTEM_WINDOWS_CUI: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(3u16);
pub const IMAGE_SUBSYSTEM_OS2_CUI: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(5u16);
pub const IMAGE_SUBSYSTEM_POSIX_CUI: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(7u16);
pub const IMAGE_SUBSYSTEM_NATIVE_WINDOWS: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(8u16);
pub const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(9u16);
pub const IMAGE_SUBSYSTEM_EFI_APPLICATION: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(10u16);
pub const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(11u16);
pub const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(12u16);
pub const IMAGE_SUBSYSTEM_EFI_ROM: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(13u16);
pub const IMAGE_SUBSYSTEM_XBOX: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(14u16);
pub const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(16u16);
pub const IMAGE_SUBSYSTEM_XBOX_CODE_CATALOG: IMAGE_SUBSYSTEM = IMAGE_SUBSYSTEM(17u16);
impl ::core::convert::From<u16> for IMAGE_SUBSYSTEM {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IMAGE_SUBSYSTEM {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMachineDebugManager(pub ::windows::core::IUnknown);
impl IMachineDebugManager {
pub unsafe fn AddApplication<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplication>>(&self, pda: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveApplication(&self, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwappcookie)).ok()
}
pub unsafe fn EnumApplications(&self) -> ::windows::core::Result<IEnumRemoteDebugApplications> {
let mut result__: <IEnumRemoteDebugApplications as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplications>(result__)
}
}
unsafe impl ::windows::core::Interface for IMachineDebugManager {
type Vtable = IMachineDebugManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2c_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IMachineDebugManager> for ::windows::core::IUnknown {
fn from(value: IMachineDebugManager) -> Self {
value.0
}
}
impl ::core::convert::From<&IMachineDebugManager> for ::windows::core::IUnknown {
fn from(value: &IMachineDebugManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMachineDebugManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMachineDebugManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMachineDebugManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, pdwappcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwappcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppeda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMachineDebugManagerCookie(pub ::windows::core::IUnknown);
impl IMachineDebugManagerCookie {
pub unsafe fn AddApplication<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplication>>(&self, pda: Param0, dwdebugappcookie: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi(), ::core::mem::transmute(dwdebugappcookie), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveApplication(&self, dwdebugappcookie: u32, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwdebugappcookie), ::core::mem::transmute(dwappcookie)).ok()
}
pub unsafe fn EnumApplications(&self) -> ::windows::core::Result<IEnumRemoteDebugApplications> {
let mut result__: <IEnumRemoteDebugApplications as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplications>(result__)
}
}
unsafe impl ::windows::core::Interface for IMachineDebugManagerCookie {
type Vtable = IMachineDebugManagerCookie_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2d_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IMachineDebugManagerCookie> for ::windows::core::IUnknown {
fn from(value: IMachineDebugManagerCookie) -> Self {
value.0
}
}
impl ::core::convert::From<&IMachineDebugManagerCookie> for ::windows::core::IUnknown {
fn from(value: &IMachineDebugManagerCookie) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMachineDebugManagerCookie {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMachineDebugManagerCookie {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMachineDebugManagerCookie_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, dwdebugappcookie: u32, pdwappcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwdebugappcookie: u32, dwappcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppeda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IMachineDebugManagerEvents(pub ::windows::core::IUnknown);
impl IMachineDebugManagerEvents {
pub unsafe fn onAddApplication<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplication>>(&self, pda: Param0, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pda.into_param().abi(), ::core::mem::transmute(dwappcookie)).ok()
}
pub unsafe fn onRemoveApplication<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplication>>(&self, pda: Param0, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pda.into_param().abi(), ::core::mem::transmute(dwappcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for IMachineDebugManagerEvents {
type Vtable = IMachineDebugManagerEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2e_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IMachineDebugManagerEvents> for ::windows::core::IUnknown {
fn from(value: IMachineDebugManagerEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&IMachineDebugManagerEvents> for ::windows::core::IUnknown {
fn from(value: &IMachineDebugManagerEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IMachineDebugManagerEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IMachineDebugManagerEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IMachineDebugManagerEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, dwappcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, dwappcookie: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelIterator(pub ::windows::core::IUnknown);
impl IModelIterator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetNext(&self, object: *mut ::core::option::Option<IModelObject>, dimensions: u64, indexers: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(object), ::core::mem::transmute(dimensions), ::core::mem::transmute(indexers), ::core::mem::transmute(metadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IModelIterator {
type Vtable = IModelIterator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe4622136_927d_4490_874f_581f3e4e3688);
}
impl ::core::convert::From<IModelIterator> for ::windows::core::IUnknown {
fn from(value: IModelIterator) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelIterator> for ::windows::core::IUnknown {
fn from(value: &IModelIterator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelIterator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelIterator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelIterator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, dimensions: u64, indexers: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelKeyReference(pub ::windows::core::IUnknown);
impl IModelKeyReference {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeyName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetOriginalObject(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetContextObject(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetKey(&self, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn GetKeyValue(&self, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IKeyStore>>(&self, object: Param0, metadata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), object.into_param().abi(), metadata.into_param().abi()).ok()
}
pub unsafe fn SetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, object: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), object.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IModelKeyReference {
type Vtable = IModelKeyReference_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5253dcf8_5aff_4c62_b302_56a289e00998);
}
impl ::core::convert::From<IModelKeyReference> for ::windows::core::IUnknown {
fn from(value: IModelKeyReference) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelKeyReference> for ::windows::core::IUnknown {
fn from(value: &IModelKeyReference) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelKeyReference {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelKeyReference {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelKeyReference_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keyname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, originalobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelKeyReference2(pub ::windows::core::IUnknown);
impl IModelKeyReference2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeyName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetOriginalObject(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetContextObject(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetKey(&self, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn GetKeyValue(&self, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IKeyStore>>(&self, object: Param0, metadata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), object.into_param().abi(), metadata.into_param().abi()).ok()
}
pub unsafe fn SetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, object: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), object.into_param().abi()).ok()
}
pub unsafe fn OverrideContextObject<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, newcontextobject: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), newcontextobject.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IModelKeyReference2 {
type Vtable = IModelKeyReference2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x80e2f7c5_7159_4e92_887e_7e0347e88406);
}
impl ::core::convert::From<IModelKeyReference2> for ::windows::core::IUnknown {
fn from(value: IModelKeyReference2) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelKeyReference2> for ::windows::core::IUnknown {
fn from(value: &IModelKeyReference2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelKeyReference2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelKeyReference2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IModelKeyReference2> for IModelKeyReference {
fn from(value: IModelKeyReference2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IModelKeyReference2> for IModelKeyReference {
fn from(value: &IModelKeyReference2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IModelKeyReference> for IModelKeyReference2 {
fn into_param(self) -> ::windows::core::Param<'a, IModelKeyReference> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IModelKeyReference> for &IModelKeyReference2 {
fn into_param(self) -> ::windows::core::Param<'a, IModelKeyReference> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelKeyReference2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, keyname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, originalobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, containingobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newcontextobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelMethod(pub ::windows::core::IUnknown);
impl IModelMethod {
pub unsafe fn Call<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, pcontextobject: Param0, argcount: u64, pparguments: *const ::core::option::Option<IModelObject>, ppresult: *mut ::core::option::Option<IModelObject>, ppmetadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pcontextobject.into_param().abi(), ::core::mem::transmute(argcount), ::core::mem::transmute(pparguments), ::core::mem::transmute(ppresult), ::core::mem::transmute(ppmetadata)).ok()
}
}
unsafe impl ::windows::core::Interface for IModelMethod {
type Vtable = IModelMethod_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x80600c1f_b90b_4896_82ad_1c00207909e8);
}
impl ::core::convert::From<IModelMethod> for ::windows::core::IUnknown {
fn from(value: IModelMethod) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelMethod> for ::windows::core::IUnknown {
fn from(value: &IModelMethod) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelMethod {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelMethod {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelMethod_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcontextobject: ::windows::core::RawPtr, argcount: u64, pparguments: *const ::windows::core::RawPtr, ppresult: *mut ::windows::core::RawPtr, ppmetadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelObject(pub ::windows::core::IUnknown);
impl IModelObject {
pub unsafe fn GetContext(&self) -> ::windows::core::Result<IDebugHostContext> {
let mut result__: <IDebugHostContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostContext>(result__)
}
pub unsafe fn GetKind(&self) -> ::windows::core::Result<ModelObjectKind> {
let mut result__: <ModelObjectKind as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ModelObjectKind>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetIntrinsicValue(&self) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetIntrinsicValueAs(&self, vt: u16) -> ::windows::core::Result<super::super::Com::VARIANT> {
let mut result__: <super::super::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(vt), &mut result__).from_abi::<super::super::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, key: Param0, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), key.into_param().abi(), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKeyValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, key: Param0, object: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), key.into_param().abi(), object.into_param().abi()).ok()
}
pub unsafe fn EnumerateKeyValues(&self) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRawValue<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1, searchflags: u32) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), ::core::mem::transmute(searchflags), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn EnumerateRawValues(&self, kind: SymbolKind, searchflags: u32) -> ::windows::core::Result<IRawEnumerator> {
let mut result__: <IRawEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), ::core::mem::transmute(searchflags), &mut result__).from_abi::<IRawEnumerator>(result__)
}
pub unsafe fn Dereference(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn TryCastToRuntimeType(&self) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn GetConcept(&self, conceptid: *const ::windows::core::GUID, conceptinterface: *mut ::core::option::Option<::windows::core::IUnknown>, conceptmetadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(conceptid), ::core::mem::transmute(conceptinterface), ::core::mem::transmute(conceptmetadata)).ok()
}
pub unsafe fn GetLocation(&self) -> ::windows::core::Result<Location> {
let mut result__: <Location as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<Location>(result__)
}
pub unsafe fn GetTypeInfo(&self) -> ::windows::core::Result<IDebugHostType> {
let mut result__: <IDebugHostType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugHostType>(result__)
}
pub unsafe fn GetTargetInfo(&self, location: *mut Location, r#type: *mut ::core::option::Option<IDebugHostType>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(location), ::core::mem::transmute(r#type)).ok()
}
pub unsafe fn GetNumberOfParentModels(&self) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn GetParentModel(&self, i: u64, model: *mut ::core::option::Option<IModelObject>, contextobject: *mut ::core::option::Option<IModelObject>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(i), ::core::mem::transmute(model), ::core::mem::transmute(contextobject)).ok()
}
pub unsafe fn AddParentModel<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, model: Param0, contextobject: Param1, r#override: u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), model.into_param().abi(), contextobject.into_param().abi(), ::core::mem::transmute(r#override)).ok()
}
pub unsafe fn RemoveParentModel<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, model: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), model.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, key: Param0, object: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), key.into_param().abi(), ::core::mem::transmute(object), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetKeyReference<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, key: Param0, objectreference: *mut ::core::option::Option<IModelObject>, metadata: *mut ::core::option::Option<IKeyStore>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), key.into_param().abi(), ::core::mem::transmute(objectreference), ::core::mem::transmute(metadata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>, Param2: ::windows::core::IntoParam<'a, IKeyStore>>(&self, key: Param0, object: Param1, metadata: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), key.into_param().abi(), object.into_param().abi(), metadata.into_param().abi()).ok()
}
pub unsafe fn ClearKeys(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumerateKeys(&self) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
pub unsafe fn EnumerateKeyReferences(&self) -> ::windows::core::Result<IKeyEnumerator> {
let mut result__: <IKeyEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IKeyEnumerator>(result__)
}
pub unsafe fn SetConcept<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param2: ::windows::core::IntoParam<'a, IKeyStore>>(&self, conceptid: *const ::windows::core::GUID, conceptinterface: Param1, conceptmetadata: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(conceptid), conceptinterface.into_param().abi(), conceptmetadata.into_param().abi()).ok()
}
pub unsafe fn ClearConcepts(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRawReference<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, kind: SymbolKind, name: Param1, searchflags: u32) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), name.into_param().abi(), ::core::mem::transmute(searchflags), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn EnumerateRawReferences(&self, kind: SymbolKind, searchflags: u32) -> ::windows::core::Result<IRawEnumerator> {
let mut result__: <IRawEnumerator as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(kind), ::core::mem::transmute(searchflags), &mut result__).from_abi::<IRawEnumerator>(result__)
}
pub unsafe fn SetContextForDataModel<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, datamodelobject: Param0, context: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), datamodelobject.into_param().abi(), context.into_param().abi()).ok()
}
pub unsafe fn GetContextForDataModel<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, datamodelobject: Param0) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), datamodelobject.into_param().abi(), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn Compare<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, other: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), other.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
pub unsafe fn IsEqualTo<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, other: Param0) -> ::windows::core::Result<bool> {
let mut result__: <bool as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), other.into_param().abi(), &mut result__).from_abi::<bool>(result__)
}
}
unsafe impl ::windows::core::Interface for IModelObject {
type Vtable = IModelObject_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe28c7893_3f4b_4b96_baca_293cdc55f45d);
}
impl ::core::convert::From<IModelObject> for ::windows::core::IUnknown {
fn from(value: IModelObject) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelObject> for ::windows::core::IUnknown {
fn from(value: &IModelObject) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelObject {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelObject_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: *mut ModelObjectKind) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, intrinsicdata: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, vt: u16, intrinsicdata: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, searchflags: u32, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, searchflags: u32, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, runtimetypedobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, conceptid: *const ::windows::core::GUID, conceptinterface: *mut ::windows::core::RawPtr, conceptmetadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: *mut Location) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: *mut Location, r#type: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nummodels: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, i: u64, model: *mut ::windows::core::RawPtr, contextobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, model: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, r#override: u8) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, model: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, objectreference: *mut ::windows::core::RawPtr, metadata: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, object: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, conceptid: *const ::windows::core::GUID, conceptinterface: ::windows::core::RawPtr, conceptmetadata: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, name: super::super::super::Foundation::PWSTR, searchflags: u32, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, kind: SymbolKind, searchflags: u32, enumerator: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodelobject: ::windows::core::RawPtr, context: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datamodelobject: ::windows::core::RawPtr, context: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, other: ::windows::core::RawPtr, ppresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, other: ::windows::core::RawPtr, equal: *mut bool) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IModelPropertyAccessor(pub ::windows::core::IUnknown);
impl IModelPropertyAccessor {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>>(&self, key: Param0, contextobject: Param1) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), key.into_param().abi(), contextobject.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, IModelObject>, Param2: ::windows::core::IntoParam<'a, IModelObject>>(&self, key: Param0, contextobject: Param1, value: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), key.into_param().abi(), contextobject.into_param().abi(), value.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IModelPropertyAccessor {
type Vtable = IModelPropertyAccessor_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5a0c63d9_0526_42b8_960c_9516a3254c85);
}
impl ::core::convert::From<IModelPropertyAccessor> for ::windows::core::IUnknown {
fn from(value: IModelPropertyAccessor) -> Self {
value.0
}
}
impl ::core::convert::From<&IModelPropertyAccessor> for ::windows::core::IUnknown {
fn from(value: &IModelPropertyAccessor) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IModelPropertyAccessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IModelPropertyAccessor {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IModelPropertyAccessor_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, contextobject: ::windows::core::RawPtr, value: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, key: super::super::super::Foundation::PWSTR, contextobject: ::windows::core::RawPtr, value: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
pub const INCORRECT_VERSION_INFO: u32 = 7u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union INLINE_FRAME_CONTEXT {
pub ContextValue: u32,
pub Anonymous: INLINE_FRAME_CONTEXT_0,
}
impl INLINE_FRAME_CONTEXT {}
impl ::core::default::Default for INLINE_FRAME_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for INLINE_FRAME_CONTEXT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for INLINE_FRAME_CONTEXT {}
unsafe impl ::windows::core::Abi for INLINE_FRAME_CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct INLINE_FRAME_CONTEXT_0 {
pub FrameId: u8,
pub FrameType: u8,
pub FrameSignature: u16,
}
impl INLINE_FRAME_CONTEXT_0 {}
impl ::core::default::Default for INLINE_FRAME_CONTEXT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for INLINE_FRAME_CONTEXT_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("FrameId", &self.FrameId).field("FrameType", &self.FrameType).field("FrameSignature", &self.FrameSignature).finish()
}
}
impl ::core::cmp::PartialEq for INLINE_FRAME_CONTEXT_0 {
fn eq(&self, other: &Self) -> bool {
self.FrameId == other.FrameId && self.FrameType == other.FrameType && self.FrameSignature == other.FrameSignature
}
}
impl ::core::cmp::Eq for INLINE_FRAME_CONTEXT_0 {}
unsafe impl ::windows::core::Abi for INLINE_FRAME_CONTEXT_0 {
type Abi = Self;
}
pub const INLINE_FRAME_CONTEXT_IGNORE: u32 = 4294967295u32;
pub const INLINE_FRAME_CONTEXT_INIT: u32 = 0u32;
pub const INSUFFICIENT_SPACE_TO_COPY: u32 = 10u32;
pub const INTERFACESAFE_FOR_UNTRUSTED_CALLER: u32 = 1u32;
pub const INTERFACESAFE_FOR_UNTRUSTED_DATA: u32 = 2u32;
pub const INTERFACE_USES_DISPEX: u32 = 4u32;
pub const INTERFACE_USES_SECURITY_MANAGER: u32 = 8u32;
pub const IOCTL_IPMI_INTERNAL_RECORD_SEL_EVENT: u32 = 2232320u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE {
pub Address: u32,
pub Length: u32,
pub Data: u32,
}
impl IOSPACE {}
impl ::core::default::Default for IOSPACE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data
}
}
impl ::core::cmp::Eq for IOSPACE {}
unsafe impl ::windows::core::Abi for IOSPACE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE32 {
pub Address: u32,
pub Length: u32,
pub Data: u32,
}
impl IOSPACE32 {}
impl ::core::default::Default for IOSPACE32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE32").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE32 {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data
}
}
impl ::core::cmp::Eq for IOSPACE32 {}
unsafe impl ::windows::core::Abi for IOSPACE32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE64 {
pub Address: u64,
pub Length: u32,
pub Data: u32,
}
impl IOSPACE64 {}
impl ::core::default::Default for IOSPACE64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE64").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE64 {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data
}
}
impl ::core::cmp::Eq for IOSPACE64 {}
unsafe impl ::windows::core::Abi for IOSPACE64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE_EX {
pub Address: u32,
pub Length: u32,
pub Data: u32,
pub InterfaceType: u32,
pub BusNumber: u32,
pub AddressSpace: u32,
}
impl IOSPACE_EX {}
impl ::core::default::Default for IOSPACE_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE_EX").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).field("InterfaceType", &self.InterfaceType).field("BusNumber", &self.BusNumber).field("AddressSpace", &self.AddressSpace).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE_EX {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data && self.InterfaceType == other.InterfaceType && self.BusNumber == other.BusNumber && self.AddressSpace == other.AddressSpace
}
}
impl ::core::cmp::Eq for IOSPACE_EX {}
unsafe impl ::windows::core::Abi for IOSPACE_EX {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE_EX32 {
pub Address: u32,
pub Length: u32,
pub Data: u32,
pub InterfaceType: u32,
pub BusNumber: u32,
pub AddressSpace: u32,
}
impl IOSPACE_EX32 {}
impl ::core::default::Default for IOSPACE_EX32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE_EX32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE_EX32").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).field("InterfaceType", &self.InterfaceType).field("BusNumber", &self.BusNumber).field("AddressSpace", &self.AddressSpace).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE_EX32 {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data && self.InterfaceType == other.InterfaceType && self.BusNumber == other.BusNumber && self.AddressSpace == other.AddressSpace
}
}
impl ::core::cmp::Eq for IOSPACE_EX32 {}
unsafe impl ::windows::core::Abi for IOSPACE_EX32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct IOSPACE_EX64 {
pub Address: u64,
pub Length: u32,
pub Data: u32,
pub InterfaceType: u32,
pub BusNumber: u32,
pub AddressSpace: u32,
}
impl IOSPACE_EX64 {}
impl ::core::default::Default for IOSPACE_EX64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for IOSPACE_EX64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("IOSPACE_EX64").field("Address", &self.Address).field("Length", &self.Length).field("Data", &self.Data).field("InterfaceType", &self.InterfaceType).field("BusNumber", &self.BusNumber).field("AddressSpace", &self.AddressSpace).finish()
}
}
impl ::core::cmp::PartialEq for IOSPACE_EX64 {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.Length == other.Length && self.Data == other.Data && self.InterfaceType == other.InterfaceType && self.BusNumber == other.BusNumber && self.AddressSpace == other.AddressSpace
}
}
impl ::core::cmp::Eq for IOSPACE_EX64 {}
unsafe impl ::windows::core::Abi for IOSPACE_EX64 {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IObjectSafety(pub ::windows::core::IUnknown);
impl IObjectSafety {
pub unsafe fn GetInterfaceSafetyOptions(&self, riid: *const ::windows::core::GUID, pdwsupportedoptions: *mut u32, pdwenabledoptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(pdwsupportedoptions), ::core::mem::transmute(pdwenabledoptions)).ok()
}
pub unsafe fn SetInterfaceSafetyOptions(&self, riid: *const ::windows::core::GUID, dwoptionsetmask: u32, dwenabledoptions: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(dwoptionsetmask), ::core::mem::transmute(dwenabledoptions)).ok()
}
}
unsafe impl ::windows::core::Interface for IObjectSafety {
type Vtable = IObjectSafety_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcb5bdc81_93c1_11cf_8f20_00805f2cd064);
}
impl ::core::convert::From<IObjectSafety> for ::windows::core::IUnknown {
fn from(value: IObjectSafety) -> Self {
value.0
}
}
impl ::core::convert::From<&IObjectSafety> for ::windows::core::IUnknown {
fn from(value: &IObjectSafety) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IObjectSafety {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IObjectSafety {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IObjectSafety_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, pdwsupportedoptions: *mut u32, pdwenabledoptions: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, dwoptionsetmask: u32, dwenabledoptions: u32) -> ::windows::core::HRESULT,
);
pub const IPMI_IOCTL_INDEX: u32 = 1024u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct IPMI_OS_SEL_RECORD {
pub Signature: u32,
pub Version: u32,
pub Length: u32,
pub RecordType: IPMI_OS_SEL_RECORD_TYPE,
pub DataLength: u32,
pub Data: [u8; 1],
}
impl IPMI_OS_SEL_RECORD {}
impl ::core::default::Default for IPMI_OS_SEL_RECORD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for IPMI_OS_SEL_RECORD {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for IPMI_OS_SEL_RECORD {}
unsafe impl ::windows::core::Abi for IPMI_OS_SEL_RECORD {
type Abi = Self;
}
pub const IPMI_OS_SEL_RECORD_MASK: u32 = 65535u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IPMI_OS_SEL_RECORD_TYPE(pub i32);
pub const IpmiOsSelRecordTypeWhea: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(0i32);
pub const IpmiOsSelRecordTypeOther: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(1i32);
pub const IpmiOsSelRecordTypeWheaErrorXpfMca: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(2i32);
pub const IpmiOsSelRecordTypeWheaErrorPci: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(3i32);
pub const IpmiOsSelRecordTypeWheaErrorNmi: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(4i32);
pub const IpmiOsSelRecordTypeWheaErrorOther: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(5i32);
pub const IpmiOsSelRecordTypeRaw: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(6i32);
pub const IpmiOsSelRecordTypeDriver: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(7i32);
pub const IpmiOsSelRecordTypeBugcheckRecovery: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(8i32);
pub const IpmiOsSelRecordTypeBugcheckData: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(9i32);
pub const IpmiOsSelRecordTypeMax: IPMI_OS_SEL_RECORD_TYPE = IPMI_OS_SEL_RECORD_TYPE(10i32);
impl ::core::convert::From<i32> for IPMI_OS_SEL_RECORD_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IPMI_OS_SEL_RECORD_TYPE {
type Abi = Self;
}
pub const IPMI_OS_SEL_RECORD_VERSION: u32 = 1u32;
pub const IPMI_OS_SEL_RECORD_VERSION_1: u32 = 1u32;
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IPerPropertyBrowsing2(pub ::windows::core::IUnknown);
impl IPerPropertyBrowsing2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDisplayString(&self, dispid: i32) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(dispid), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn MapPropertyToPage(&self, dispid: i32) -> ::windows::core::Result<::windows::core::GUID> {
let mut result__: <::windows::core::GUID as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(dispid), &mut result__).from_abi::<::windows::core::GUID>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole"))]
pub unsafe fn GetPredefinedStrings(&self, dispid: i32, pcastrings: *mut super::super::Ole::CALPOLESTR, pcacookies: *mut super::super::Ole::CADWORD) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dispid), ::core::mem::transmute(pcastrings), ::core::mem::transmute(pcacookies)).ok()
}
pub unsafe fn SetPredefinedValue(&self, dispid: i32, dwcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dispid), ::core::mem::transmute(dwcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for IPerPropertyBrowsing2 {
type Vtable = IPerPropertyBrowsing2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c54_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IPerPropertyBrowsing2> for ::windows::core::IUnknown {
fn from(value: IPerPropertyBrowsing2) -> Self {
value.0
}
}
impl ::core::convert::From<&IPerPropertyBrowsing2> for ::windows::core::IUnknown {
fn from(value: &IPerPropertyBrowsing2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IPerPropertyBrowsing2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IPerPropertyBrowsing2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IPerPropertyBrowsing2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispid: i32, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispid: i32, pclsidproppage: *mut ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispid: i32, pcastrings: *mut super::super::Ole::CALPOLESTR, pcacookies: *mut super::super::Ole::CADWORD) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispid: i32, dwcookie: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IPreferredRuntimeTypeConcept(pub ::windows::core::IUnknown);
impl IPreferredRuntimeTypeConcept {
pub unsafe fn CastToPreferredRuntimeType<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>>(&self, contextobject: Param0) -> ::windows::core::Result<IModelObject> {
let mut result__: <IModelObject as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), &mut result__).from_abi::<IModelObject>(result__)
}
}
unsafe impl ::windows::core::Interface for IPreferredRuntimeTypeConcept {
type Vtable = IPreferredRuntimeTypeConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9d6c1d7b_a76f_4618_8068_5f76bd9a4e8a);
}
impl ::core::convert::From<IPreferredRuntimeTypeConcept> for ::windows::core::IUnknown {
fn from(value: IPreferredRuntimeTypeConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IPreferredRuntimeTypeConcept> for ::windows::core::IUnknown {
fn from(value: &IPreferredRuntimeTypeConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IPreferredRuntimeTypeConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IPreferredRuntimeTypeConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IPreferredRuntimeTypeConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IProcessDebugManager32(pub ::windows::core::IUnknown);
impl IProcessDebugManager32 {
pub unsafe fn CreateApplication(&self) -> ::windows::core::Result<IDebugApplication32> {
let mut result__: <IDebugApplication32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication32>(result__)
}
pub unsafe fn GetDefaultApplication(&self) -> ::windows::core::Result<IDebugApplication32> {
let mut result__: <IDebugApplication32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication32>(result__)
}
pub unsafe fn AddApplication<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplication32>>(&self, pda: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pda.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveApplication(&self, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwappcookie)).ok()
}
pub unsafe fn CreateDebugDocumentHelper<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkouter: Param0) -> ::windows::core::Result<IDebugDocumentHelper32> {
let mut result__: <IDebugDocumentHelper32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), punkouter.into_param().abi(), &mut result__).from_abi::<IDebugDocumentHelper32>(result__)
}
}
unsafe impl ::windows::core::Interface for IProcessDebugManager32 {
type Vtable = IProcessDebugManager32_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c2f_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IProcessDebugManager32> for ::windows::core::IUnknown {
fn from(value: IProcessDebugManager32) -> Self {
value.0
}
}
impl ::core::convert::From<&IProcessDebugManager32> for ::windows::core::IUnknown {
fn from(value: &IProcessDebugManager32) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IProcessDebugManager32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IProcessDebugManager32 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IProcessDebugManager32_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, pdwappcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwappcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkouter: ::windows::core::RawPtr, pddh: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IProcessDebugManager64(pub ::windows::core::IUnknown);
impl IProcessDebugManager64 {
pub unsafe fn CreateApplication(&self) -> ::windows::core::Result<IDebugApplication64> {
let mut result__: <IDebugApplication64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication64>(result__)
}
pub unsafe fn GetDefaultApplication(&self) -> ::windows::core::Result<IDebugApplication64> {
let mut result__: <IDebugApplication64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplication64>(result__)
}
pub unsafe fn AddApplication<'a, Param0: ::windows::core::IntoParam<'a, IDebugApplication64>>(&self, pda: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pda.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn RemoveApplication(&self, dwappcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwappcookie)).ok()
}
pub unsafe fn CreateDebugDocumentHelper<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkouter: Param0) -> ::windows::core::Result<IDebugDocumentHelper64> {
let mut result__: <IDebugDocumentHelper64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), punkouter.into_param().abi(), &mut result__).from_abi::<IDebugDocumentHelper64>(result__)
}
}
unsafe impl ::windows::core::Interface for IProcessDebugManager64 {
type Vtable = IProcessDebugManager64_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x56b9fc1c_63a9_4cc1_ac21_087d69a17fab);
}
impl ::core::convert::From<IProcessDebugManager64> for ::windows::core::IUnknown {
fn from(value: IProcessDebugManager64) -> Self {
value.0
}
}
impl ::core::convert::From<&IProcessDebugManager64> for ::windows::core::IUnknown {
fn from(value: &IProcessDebugManager64) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IProcessDebugManager64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IProcessDebugManager64 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IProcessDebugManager64_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pda: ::windows::core::RawPtr, pdwappcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwappcookie: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkouter: ::windows::core::RawPtr, pddh: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IProvideExpressionContexts(pub ::windows::core::IUnknown);
impl IProvideExpressionContexts {
pub unsafe fn EnumExpressionContexts(&self) -> ::windows::core::Result<IEnumDebugExpressionContexts> {
let mut result__: <IEnumDebugExpressionContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExpressionContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IProvideExpressionContexts {
type Vtable = IProvideExpressionContexts_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c41_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IProvideExpressionContexts> for ::windows::core::IUnknown {
fn from(value: IProvideExpressionContexts) -> Self {
value.0
}
}
impl ::core::convert::From<&IProvideExpressionContexts> for ::windows::core::IUnknown {
fn from(value: &IProvideExpressionContexts) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IProvideExpressionContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IProvideExpressionContexts {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IProvideExpressionContexts_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedec: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRawEnumerator(pub ::windows::core::IUnknown);
impl IRawEnumerator {
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNext(&self, name: *mut super::super::super::Foundation::BSTR, kind: *mut SymbolKind, value: *mut ::core::option::Option<IModelObject>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(name), ::core::mem::transmute(kind), ::core::mem::transmute(value)).ok()
}
}
unsafe impl ::windows::core::Interface for IRawEnumerator {
type Vtable = IRawEnumerator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe13613f9_3a3c_40b5_8f48_1e5ebfb9b21b);
}
impl ::core::convert::From<IRawEnumerator> for ::windows::core::IUnknown {
fn from(value: IRawEnumerator) -> Self {
value.0
}
}
impl ::core::convert::From<&IRawEnumerator> for ::windows::core::IUnknown {
fn from(value: &IRawEnumerator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRawEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRawEnumerator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRawEnumerator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, kind: *mut SymbolKind, value: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugApplication(pub ::windows::core::IUnknown);
impl IRemoteDebugApplication {
pub unsafe fn ResumeFromBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prptfocus: Param0, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), prptfocus.into_param().abi(), ::core::mem::transmute(bra), ::core::mem::transmute(era)).ok()
}
pub unsafe fn CauseBreak(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ConnectDebugger<'a, Param0: ::windows::core::IntoParam<'a, IApplicationDebugger>>(&self, pad: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pad.into_param().abi()).ok()
}
pub unsafe fn DisconnectDebugger(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetDebugger(&self) -> ::windows::core::Result<IApplicationDebugger> {
let mut result__: <IApplicationDebugger as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IApplicationDebugger>(result__)
}
pub unsafe fn CreateInstanceAtApplication<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, rclsid: *const ::windows::core::GUID, punkouter: Param1, dwclscontext: u32, riid: *const ::windows::core::GUID) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(rclsid), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn QueryAlive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn EnumThreads(&self) -> ::windows::core::Result<IEnumRemoteDebugApplicationThreads> {
let mut result__: <IEnumRemoteDebugApplicationThreads as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumRemoteDebugApplicationThreads>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetRootNode(&self) -> ::windows::core::Result<IDebugApplicationNode> {
let mut result__: <IDebugApplicationNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IDebugApplicationNode>(result__)
}
pub unsafe fn EnumGlobalExpressionContexts(&self) -> ::windows::core::Result<IEnumDebugExpressionContexts> {
let mut result__: <IEnumDebugExpressionContexts as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugExpressionContexts>(result__)
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugApplication {
type Vtable = IRemoteDebugApplication_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c30_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IRemoteDebugApplication> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugApplication) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugApplication> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugApplication) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugApplication {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugApplication {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugApplication_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prptfocus: ::windows::core::RawPtr, bra: BREAKRESUME_ACTION, era: ERRORRESUMEACTION) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rclsid: *const ::windows::core::GUID, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pperdat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrname: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppdanroot: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedec: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugApplication110(pub ::windows::core::IUnknown);
impl IRemoteDebugApplication110 {
pub unsafe fn SetDebuggerOptions(&self, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(mask), ::core::mem::transmute(value)).ok()
}
pub unsafe fn GetCurrentDebuggerOptions(&self) -> ::windows::core::Result<SCRIPT_DEBUGGER_OPTIONS> {
let mut result__: <SCRIPT_DEBUGGER_OPTIONS as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPT_DEBUGGER_OPTIONS>(result__)
}
pub unsafe fn GetMainThread(&self) -> ::windows::core::Result<IRemoteDebugApplicationThread> {
let mut result__: <IRemoteDebugApplicationThread as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplicationThread>(result__)
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugApplication110 {
type Vtable = IRemoteDebugApplication110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd5fe005b_2836_485e_b1f9_89d91aa24fd4);
}
impl ::core::convert::From<IRemoteDebugApplication110> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugApplication110) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugApplication110> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugApplication110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugApplication110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugApplication110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugApplication110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mask: SCRIPT_DEBUGGER_OPTIONS, value: SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcurrentoptions: *mut SCRIPT_DEBUGGER_OPTIONS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppthread: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugApplicationEvents(pub ::windows::core::IUnknown);
impl IRemoteDebugApplicationEvents {
pub unsafe fn OnConnectDebugger<'a, Param0: ::windows::core::IntoParam<'a, IApplicationDebugger>>(&self, pad: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pad.into_param().abi()).ok()
}
pub unsafe fn OnDisconnectDebugger(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnSetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pstrname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OnDebugOutput<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstr: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pstr.into_param().abi()).ok()
}
pub unsafe fn OnClose(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn OnEnterBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prdat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), prdat.into_param().abi()).ok()
}
pub unsafe fn OnLeaveBreakPoint<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prdat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), prdat.into_param().abi()).ok()
}
pub unsafe fn OnCreateThread<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prdat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), prdat.into_param().abi()).ok()
}
pub unsafe fn OnDestroyThread<'a, Param0: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, prdat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), prdat.into_param().abi()).ok()
}
pub unsafe fn OnBreakFlagChange<'a, Param1: ::windows::core::IntoParam<'a, IRemoteDebugApplicationThread>>(&self, abf: u32, prdatsteppingthread: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(abf), prdatsteppingthread.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugApplicationEvents {
type Vtable = IRemoteDebugApplicationEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c33_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IRemoteDebugApplicationEvents> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugApplicationEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugApplicationEvents> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugApplicationEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugApplicationEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugApplicationEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugApplicationEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pad: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrname: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstr: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prdat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prdat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prdat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prdat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, abf: u32, prdatsteppingthread: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugApplicationThread(pub ::windows::core::IUnknown);
impl IRemoteDebugApplicationThread {
pub unsafe fn GetSystemThreadId(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetApplication(&self) -> ::windows::core::Result<IRemoteDebugApplication> {
let mut result__: <IRemoteDebugApplication as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IRemoteDebugApplication>(result__)
}
pub unsafe fn EnumStackFrames(&self) -> ::windows::core::Result<IEnumDebugStackFrames> {
let mut result__: <IEnumDebugStackFrames as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumDebugStackFrames>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, pbstrdescription: *mut super::super::super::Foundation::BSTR, pbstrstate: *mut super::super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrdescription), ::core::mem::transmute(pbstrstate)).ok()
}
pub unsafe fn SetNextStatement<'a, Param0: ::windows::core::IntoParam<'a, IDebugStackFrame>, Param1: ::windows::core::IntoParam<'a, IDebugCodeContext>>(&self, pstackframe: Param0, pcodecontext: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstackframe.into_param().abi(), pcodecontext.into_param().abi()).ok()
}
pub unsafe fn GetState(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Suspend(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetSuspendCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugApplicationThread {
type Vtable = IRemoteDebugApplicationThread_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c37_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<IRemoteDebugApplicationThread> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugApplicationThread) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugApplicationThread> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugApplicationThread) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugApplicationThread {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugApplicationThread_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwthreadid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprda: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppedsf: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pbstrstate: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstackframe: ::windows::core::RawPtr, pcodecontext: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstate: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcount: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugCriticalErrorEvent110(pub ::windows::core::IUnknown);
impl IRemoteDebugCriticalErrorEvent110 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetErrorInfo(&self, pbstrsource: *mut super::super::super::Foundation::BSTR, pmessageid: *mut i32, pbstrmessage: *mut super::super::super::Foundation::BSTR, pplocation: *mut ::core::option::Option<IDebugDocumentContext>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbstrsource), ::core::mem::transmute(pmessageid), ::core::mem::transmute(pbstrmessage), ::core::mem::transmute(pplocation)).ok()
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugCriticalErrorEvent110 {
type Vtable = IRemoteDebugCriticalErrorEvent110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2f69c611_6b14_47e8_9260_4bb7c52f504b);
}
impl ::core::convert::From<IRemoteDebugCriticalErrorEvent110> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugCriticalErrorEvent110) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugCriticalErrorEvent110> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugCriticalErrorEvent110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugCriticalErrorEvent110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugCriticalErrorEvent110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugCriticalErrorEvent110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrsource: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pmessageid: *mut i32, pbstrmessage: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pplocation: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IRemoteDebugInfoEvent110(pub ::windows::core::IUnknown);
impl IRemoteDebugInfoEvent110 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventInfo(&self, pmessagetype: *mut DEBUG_EVENT_INFO_TYPE, pbstrmessage: *mut super::super::super::Foundation::BSTR, pbstrurl: *mut super::super::super::Foundation::BSTR, pplocation: *mut ::core::option::Option<IDebugDocumentContext>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmessagetype), ::core::mem::transmute(pbstrmessage), ::core::mem::transmute(pbstrurl), ::core::mem::transmute(pplocation)).ok()
}
}
unsafe impl ::windows::core::Interface for IRemoteDebugInfoEvent110 {
type Vtable = IRemoteDebugInfoEvent110_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ff56bb6_eb89_4c0f_8823_cc2a4c0b7f26);
}
impl ::core::convert::From<IRemoteDebugInfoEvent110> for ::windows::core::IUnknown {
fn from(value: IRemoteDebugInfoEvent110) -> Self {
value.0
}
}
impl ::core::convert::From<&IRemoteDebugInfoEvent110> for ::windows::core::IUnknown {
fn from(value: &IRemoteDebugInfoEvent110) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IRemoteDebugInfoEvent110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IRemoteDebugInfoEvent110 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IRemoteDebugInfoEvent110_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmessagetype: *mut DEBUG_EVENT_INFO_TYPE, pbstrmessage: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pbstrurl: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pplocation: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IScriptEntry(pub ::windows::core::IUnknown);
impl IScriptEntry {
pub unsafe fn Alive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Delete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IScriptNode>(result__)
}
pub unsafe fn GetIndexInParent(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCookie(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOfChildren(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetChild(&self, isn: u32) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), &mut result__).from_abi::<IScriptNode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateChildEntry<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, isn: u32, dwcookie: u32, pszdelimiter: Param2) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), ::core::mem::transmute(dwcookie), pszdelimiter.into_param().abi(), &mut result__).from_abi::<IScriptEntry>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn CreateChildHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::Com::ITypeInfo>>(
&self,
pszdefaultname: Param0,
prgpsznames: *const super::super::super::Foundation::PWSTR,
cpsznames: u32,
pszevent: Param3,
pszdelimiter: Param4,
ptisignature: Param5,
imethodsignature: u32,
isn: u32,
dwcookie: u32,
) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(
::core::mem::transmute_copy(self),
pszdefaultname.into_param().abi(),
::core::mem::transmute(prgpsznames),
::core::mem::transmute(cpsznames),
pszevent.into_param().abi(),
pszdelimiter.into_param().abi(),
ptisignature.into_param().abi(),
::core::mem::transmute(imethodsignature),
::core::mem::transmute(isn),
::core::mem::transmute(dwcookie),
&mut result__,
)
.from_abi::<IScriptEntry>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetBody(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetBody<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetItemName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetItemName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetSignature(&self, ppti: *mut ::core::option::Option<super::super::Com::ITypeInfo>, pimethod: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppti), ::core::mem::transmute(pimethod)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn SetSignature<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::ITypeInfo>>(&self, pti: Param0, imethod: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), pti.into_param().abi(), ::core::mem::transmute(imethod)).ok()
}
pub unsafe fn GetRange(&self, pichmin: *mut u32, pcch: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(pichmin), ::core::mem::transmute(pcch)).ok()
}
}
unsafe impl ::windows::core::Interface for IScriptEntry {
type Vtable = IScriptEntry_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0aee2a95_bcbb_11d0_8c72_00c04fc2b085);
}
impl ::core::convert::From<IScriptEntry> for ::windows::core::IUnknown {
fn from(value: IScriptEntry) -> Self {
value.0
}
}
impl ::core::convert::From<&IScriptEntry> for ::windows::core::IUnknown {
fn from(value: &IScriptEntry) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IScriptEntry {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IScriptEntry {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IScriptEntry> for IScriptNode {
fn from(value: IScriptEntry) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IScriptEntry> for IScriptNode {
fn from(value: &IScriptEntry) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptNode> for IScriptEntry {
fn into_param(self) -> ::windows::core::Param<'a, IScriptNode> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptNode> for &IScriptEntry {
fn into_param(self) -> ::windows::core::Param<'a, IScriptNode> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IScriptEntry_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsnparent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pisn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcsn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, ppsn: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, dwcookie: u32, pszdelimiter: super::super::super::Foundation::PWSTR, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdefaultname: super::super::super::Foundation::PWSTR, prgpsznames: *const super::super::super::Foundation::PWSTR, cpsznames: u32, pszevent: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, ptisignature: ::windows::core::RawPtr, imethodsignature: u32, isn: u32, dwcookie: u32, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppti: *mut ::windows::core::RawPtr, pimethod: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pti: ::windows::core::RawPtr, imethod: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pichmin: *mut u32, pcch: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IScriptInvocationContext(pub ::windows::core::IUnknown);
impl IScriptInvocationContext {
pub unsafe fn GetContextType(&self) -> ::windows::core::Result<SCRIPT_INVOCATION_CONTEXT_TYPE> {
let mut result__: <SCRIPT_INVOCATION_CONTEXT_TYPE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SCRIPT_INVOCATION_CONTEXT_TYPE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetContextDescription(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetContextObject(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for IScriptInvocationContext {
type Vtable = IScriptInvocationContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5d7741b7_af7e_4a2a_85e5_c77f4d0659fb);
}
impl ::core::convert::From<IScriptInvocationContext> for ::windows::core::IUnknown {
fn from(value: IScriptInvocationContext) -> Self {
value.0
}
}
impl ::core::convert::From<&IScriptInvocationContext> for ::windows::core::IUnknown {
fn from(value: &IScriptInvocationContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IScriptInvocationContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IScriptInvocationContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IScriptInvocationContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinvocationcontexttype: *mut SCRIPT_INVOCATION_CONTEXT_TYPE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdescription: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcontextobject: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IScriptNode(pub ::windows::core::IUnknown);
impl IScriptNode {
pub unsafe fn Alive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Delete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IScriptNode>(result__)
}
pub unsafe fn GetIndexInParent(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCookie(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOfChildren(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetChild(&self, isn: u32) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), &mut result__).from_abi::<IScriptNode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateChildEntry<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, isn: u32, dwcookie: u32, pszdelimiter: Param2) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), ::core::mem::transmute(dwcookie), pszdelimiter.into_param().abi(), &mut result__).from_abi::<IScriptEntry>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn CreateChildHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::Com::ITypeInfo>>(
&self,
pszdefaultname: Param0,
prgpsznames: *const super::super::super::Foundation::PWSTR,
cpsznames: u32,
pszevent: Param3,
pszdelimiter: Param4,
ptisignature: Param5,
imethodsignature: u32,
isn: u32,
dwcookie: u32,
) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(
::core::mem::transmute_copy(self),
pszdefaultname.into_param().abi(),
::core::mem::transmute(prgpsznames),
::core::mem::transmute(cpsznames),
pszevent.into_param().abi(),
pszdelimiter.into_param().abi(),
ptisignature.into_param().abi(),
::core::mem::transmute(imethodsignature),
::core::mem::transmute(isn),
::core::mem::transmute(dwcookie),
&mut result__,
)
.from_abi::<IScriptEntry>(result__)
}
}
unsafe impl ::windows::core::Interface for IScriptNode {
type Vtable = IScriptNode_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0aee2a94_bcbb_11d0_8c72_00c04fc2b085);
}
impl ::core::convert::From<IScriptNode> for ::windows::core::IUnknown {
fn from(value: IScriptNode) -> Self {
value.0
}
}
impl ::core::convert::From<&IScriptNode> for ::windows::core::IUnknown {
fn from(value: &IScriptNode) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IScriptNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IScriptNode {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IScriptNode_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsnparent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pisn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcsn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, ppsn: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, dwcookie: u32, pszdelimiter: super::super::super::Foundation::PWSTR, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdefaultname: super::super::super::Foundation::PWSTR, prgpsznames: *const super::super::super::Foundation::PWSTR, cpsznames: u32, pszevent: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, ptisignature: ::windows::core::RawPtr, imethodsignature: u32, isn: u32, dwcookie: u32, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IScriptScriptlet(pub ::windows::core::IUnknown);
impl IScriptScriptlet {
pub unsafe fn Alive(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Delete(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetParent(&self) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IScriptNode>(result__)
}
pub unsafe fn GetIndexInParent(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetCookie(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetNumberOfChildren(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn GetChild(&self, isn: u32) -> ::windows::core::Result<IScriptNode> {
let mut result__: <IScriptNode as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), &mut result__).from_abi::<IScriptNode>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLanguage(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateChildEntry<'a, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, isn: u32, dwcookie: u32, pszdelimiter: Param2) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(isn), ::core::mem::transmute(dwcookie), pszdelimiter.into_param().abi(), &mut result__).from_abi::<IScriptEntry>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn CreateChildHandler<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, super::super::Com::ITypeInfo>>(
&self,
pszdefaultname: Param0,
prgpsznames: *const super::super::super::Foundation::PWSTR,
cpsznames: u32,
pszevent: Param3,
pszdelimiter: Param4,
ptisignature: Param5,
imethodsignature: u32,
isn: u32,
dwcookie: u32,
) -> ::windows::core::Result<IScriptEntry> {
let mut result__: <IScriptEntry as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(
::core::mem::transmute_copy(self),
pszdefaultname.into_param().abi(),
::core::mem::transmute(prgpsznames),
::core::mem::transmute(cpsznames),
pszevent.into_param().abi(),
pszdelimiter.into_param().abi(),
ptisignature.into_param().abi(),
::core::mem::transmute(imethodsignature),
::core::mem::transmute(isn),
::core::mem::transmute(dwcookie),
&mut result__,
)
.from_abi::<IScriptEntry>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetText<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetBody(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetBody<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetItemName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetItemName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetSignature(&self, ppti: *mut ::core::option::Option<super::super::Com::ITypeInfo>, pimethod: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppti), ::core::mem::transmute(pimethod)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn SetSignature<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::ITypeInfo>>(&self, pti: Param0, imethod: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), pti.into_param().abi(), ::core::mem::transmute(imethod)).ok()
}
pub unsafe fn GetRange(&self, pichmin: *mut u32, pcch: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(pichmin), ::core::mem::transmute(pcch)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSubItemName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSubItemName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetEventName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetSimpleEventName(&self) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetSimpleEventName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, psz: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), psz.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IScriptScriptlet {
type Vtable = IScriptScriptlet_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0aee2a96_bcbb_11d0_8c72_00c04fc2b085);
}
impl ::core::convert::From<IScriptScriptlet> for ::windows::core::IUnknown {
fn from(value: IScriptScriptlet) -> Self {
value.0
}
}
impl ::core::convert::From<&IScriptScriptlet> for ::windows::core::IUnknown {
fn from(value: &IScriptScriptlet) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<IScriptScriptlet> for IScriptEntry {
fn from(value: IScriptScriptlet) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IScriptScriptlet> for IScriptEntry {
fn from(value: &IScriptScriptlet) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptEntry> for IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, IScriptEntry> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptEntry> for &IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, IScriptEntry> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<IScriptScriptlet> for IScriptNode {
fn from(value: IScriptScriptlet) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&IScriptScriptlet> for IScriptNode {
fn from(value: &IScriptScriptlet) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptNode> for IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, IScriptNode> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, IScriptNode> for &IScriptScriptlet {
fn into_param(self) -> ::windows::core::Param<'a, IScriptNode> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IScriptScriptlet_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsnparent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pisn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcsn: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, ppsn: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, isn: u32, dwcookie: u32, pszdelimiter: super::super::super::Foundation::PWSTR, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdefaultname: super::super::super::Foundation::PWSTR, prgpsznames: *const super::super::super::Foundation::PWSTR, cpsznames: u32, pszevent: super::super::super::Foundation::PWSTR, pszdelimiter: super::super::super::Foundation::PWSTR, ptisignature: ::windows::core::RawPtr, imethodsignature: u32, isn: u32, dwcookie: u32, ppse: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppti: *mut ::windows::core::RawPtr, pimethod: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pti: ::windows::core::RawPtr, imethod: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pichmin: *mut u32, pcch: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psz: super::super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISimpleConnectionPoint(pub ::windows::core::IUnknown);
impl ISimpleConnectionPoint {
pub unsafe fn GetEventCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DescribeEvents(&self, ievent: u32, cevents: u32, prgid: *mut i32, prgbstr: *mut super::super::super::Foundation::BSTR, pceventsfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ievent), ::core::mem::transmute(cevents), ::core::mem::transmute(prgid), ::core::mem::transmute(prgbstr), ::core::mem::transmute(pceventsfetched)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Advise<'a, Param0: ::windows::core::IntoParam<'a, super::super::Com::IDispatch>>(&self, pdisp: Param0) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pdisp.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
pub unsafe fn Unadvise(&self, dwcookie: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwcookie)).ok()
}
}
unsafe impl ::windows::core::Interface for ISimpleConnectionPoint {
type Vtable = ISimpleConnectionPoint_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x51973c3e_cb0c_11d0_b5c9_00a0244a0e7a);
}
impl ::core::convert::From<ISimpleConnectionPoint> for ::windows::core::IUnknown {
fn from(value: ISimpleConnectionPoint) -> Self {
value.0
}
}
impl ::core::convert::From<&ISimpleConnectionPoint> for ::windows::core::IUnknown {
fn from(value: &ISimpleConnectionPoint) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISimpleConnectionPoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISimpleConnectionPoint {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISimpleConnectionPoint_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulcount: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ievent: u32, cevents: u32, prgid: *mut i32, prgbstr: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>, pceventsfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdisp: ::windows::core::RawPtr, pdwcookie: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwcookie: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IStringDisplayableConcept(pub ::windows::core::IUnknown);
impl IStringDisplayableConcept {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ToDisplayString<'a, Param0: ::windows::core::IntoParam<'a, IModelObject>, Param1: ::windows::core::IntoParam<'a, IKeyStore>>(&self, contextobject: Param0, metadata: Param1) -> ::windows::core::Result<super::super::super::Foundation::BSTR> {
let mut result__: <super::super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), contextobject.into_param().abi(), metadata.into_param().abi(), &mut result__).from_abi::<super::super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for IStringDisplayableConcept {
type Vtable = IStringDisplayableConcept_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd28e8d70_6c00_4205_940d_501016601ea3);
}
impl ::core::convert::From<IStringDisplayableConcept> for ::windows::core::IUnknown {
fn from(value: IStringDisplayableConcept) -> Self {
value.0
}
}
impl ::core::convert::From<&IStringDisplayableConcept> for ::windows::core::IUnknown {
fn from(value: &IStringDisplayableConcept) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IStringDisplayableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IStringDisplayableConcept {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IStringDisplayableConcept_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, contextobject: ::windows::core::RawPtr, metadata: ::windows::core::RawPtr, displaystring: *mut ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ITridentEventSink(pub ::windows::core::IUnknown);
impl ITridentEventSink {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn FireEvent<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(&self, pstrevent: Param0, pdp: *const super::super::Com::DISPPARAMS, pvarres: *mut super::super::Com::VARIANT, pei: *mut super::super::Com::EXCEPINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pstrevent.into_param().abi(), ::core::mem::transmute(pdp), ::core::mem::transmute(pvarres), ::core::mem::transmute(pei)).ok()
}
}
unsafe impl ::windows::core::Interface for ITridentEventSink {
type Vtable = ITridentEventSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1dc9ca50_06ef_11d2_8415_006008c3fbfc);
}
impl ::core::convert::From<ITridentEventSink> for ::windows::core::IUnknown {
fn from(value: ITridentEventSink) -> Self {
value.0
}
}
impl ::core::convert::From<&ITridentEventSink> for ::windows::core::IUnknown {
fn from(value: &ITridentEventSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ITridentEventSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ITridentEventSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ITridentEventSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstrevent: super::super::super::Foundation::PWSTR, pdp: *const super::super::Com::DISPPARAMS, pvarres: *mut ::core::mem::ManuallyDrop<super::super::Com::VARIANT>, pei: *mut ::core::mem::ManuallyDrop<super::super::Com::EXCEPINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWebAppDiagnosticsObjectInitialization(pub ::windows::core::IUnknown);
impl IWebAppDiagnosticsObjectInitialization {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Initialize<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE_PTR>, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hpassedhandle: Param0, pdebugapplication: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), hpassedhandle.into_param().abi(), pdebugapplication.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for IWebAppDiagnosticsObjectInitialization {
type Vtable = IWebAppDiagnosticsObjectInitialization_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x16ff3a42_a5f5_432b_b625_8e8e16f57e15);
}
impl ::core::convert::From<IWebAppDiagnosticsObjectInitialization> for ::windows::core::IUnknown {
fn from(value: IWebAppDiagnosticsObjectInitialization) -> Self {
value.0
}
}
impl ::core::convert::From<&IWebAppDiagnosticsObjectInitialization> for ::windows::core::IUnknown {
fn from(value: &IWebAppDiagnosticsObjectInitialization) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWebAppDiagnosticsObjectInitialization {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWebAppDiagnosticsObjectInitialization {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWebAppDiagnosticsObjectInitialization_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hpassedhandle: super::super::super::Foundation::HANDLE_PTR, pdebugapplication: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IWebAppDiagnosticsSetup(pub ::windows::core::IUnknown);
impl IWebAppDiagnosticsSetup {
pub unsafe fn DiagnosticsSupported(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn CreateObjectWithSiteAtWebApp(&self, rclsid: *const ::windows::core::GUID, dwclscontext: u32, riid: *const ::windows::core::GUID, hpasstoobject: usize) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(rclsid), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), ::core::mem::transmute(hpasstoobject)).ok()
}
}
unsafe impl ::windows::core::Interface for IWebAppDiagnosticsSetup {
type Vtable = IWebAppDiagnosticsSetup_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x379bfbe1_c6c9_432a_93e1_6d17656c538c);
}
impl ::core::convert::From<IWebAppDiagnosticsSetup> for ::windows::core::IUnknown {
fn from(value: IWebAppDiagnosticsSetup) -> Self {
value.0
}
}
impl ::core::convert::From<&IWebAppDiagnosticsSetup> for ::windows::core::IUnknown {
fn from(value: &IWebAppDiagnosticsSetup) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IWebAppDiagnosticsSetup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IWebAppDiagnosticsSetup {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IWebAppDiagnosticsSetup_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pretval: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rclsid: *const ::windows::core::GUID, dwclscontext: u32, riid: *const ::windows::core::GUID, hpasstoobject: usize) -> ::windows::core::HRESULT,
);
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_WinTrust"))]
#[inline]
pub unsafe fn ImageAddCertificate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, certificate: *const super::super::super::Security::WinTrust::WIN_CERTIFICATE, index: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageAddCertificate(filehandle: super::super::super::Foundation::HANDLE, certificate: *const super::super::super::Security::WinTrust::WIN_CERTIFICATE, index: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageAddCertificate(filehandle.into_param().abi(), ::core::mem::transmute(certificate), ::core::mem::transmute(index)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ImageDirectoryEntryToData<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(base: *const ::core::ffi::c_void, mappedasimage: Param1, directoryentry: IMAGE_DIRECTORY_ENTRY, size: *mut u32) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageDirectoryEntryToData(base: *const ::core::ffi::c_void, mappedasimage: super::super::super::Foundation::BOOLEAN, directoryentry: IMAGE_DIRECTORY_ENTRY, size: *mut u32) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(ImageDirectoryEntryToData(::core::mem::transmute(base), mappedasimage.into_param().abi(), ::core::mem::transmute(directoryentry), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ImageDirectoryEntryToDataEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOLEAN>>(base: *const ::core::ffi::c_void, mappedasimage: Param1, directoryentry: IMAGE_DIRECTORY_ENTRY, size: *mut u32, foundheader: *mut *mut IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageDirectoryEntryToDataEx(base: *const ::core::ffi::c_void, mappedasimage: super::super::super::Foundation::BOOLEAN, directoryentry: IMAGE_DIRECTORY_ENTRY, size: *mut u32, foundheader: *mut *mut IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(ImageDirectoryEntryToDataEx(::core::mem::transmute(base), mappedasimage.into_param().abi(), ::core::mem::transmute(directoryentry), ::core::mem::transmute(size), ::core::mem::transmute(foundheader)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ImageEnumerateCertificates<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, typefilter: u16, certificatecount: *mut u32, indices: *mut u32, indexcount: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageEnumerateCertificates(filehandle: super::super::super::Foundation::HANDLE, typefilter: u16, certificatecount: *mut u32, indices: *mut u32, indexcount: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageEnumerateCertificates(filehandle.into_param().abi(), ::core::mem::transmute(typefilter), ::core::mem::transmute(certificatecount), ::core::mem::transmute(indices), ::core::mem::transmute(indexcount)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_WinTrust"))]
#[inline]
pub unsafe fn ImageGetCertificateData<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, certificateindex: u32, certificate: *mut super::super::super::Security::WinTrust::WIN_CERTIFICATE, requiredlength: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageGetCertificateData(filehandle: super::super::super::Foundation::HANDLE, certificateindex: u32, certificate: *mut super::super::super::Security::WinTrust::WIN_CERTIFICATE, requiredlength: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageGetCertificateData(filehandle.into_param().abi(), ::core::mem::transmute(certificateindex), ::core::mem::transmute(certificate), ::core::mem::transmute(requiredlength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Security_WinTrust"))]
#[inline]
pub unsafe fn ImageGetCertificateHeader<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, certificateindex: u32, certificateheader: *mut super::super::super::Security::WinTrust::WIN_CERTIFICATE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageGetCertificateHeader(filehandle: super::super::super::Foundation::HANDLE, certificateindex: u32, certificateheader: *mut super::super::super::Security::WinTrust::WIN_CERTIFICATE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageGetCertificateHeader(filehandle.into_param().abi(), ::core::mem::transmute(certificateindex), ::core::mem::transmute(certificateheader)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ImageGetDigestStream<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, digestlevel: u32, digestfunction: ::core::option::Option<DIGEST_FUNCTION>, digesthandle: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageGetDigestStream(filehandle: super::super::super::Foundation::HANDLE, digestlevel: u32, digestfunction: ::windows::core::RawPtr, digesthandle: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageGetDigestStream(filehandle.into_param().abi(), ::core::mem::transmute(digestlevel), ::core::mem::transmute(digestfunction), ::core::mem::transmute(digesthandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn ImageLoad<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(dllname: Param0, dllpath: Param1) -> *mut LOADED_IMAGE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageLoad(dllname: super::super::super::Foundation::PSTR, dllpath: super::super::super::Foundation::PSTR) -> *mut LOADED_IMAGE;
}
::core::mem::transmute(ImageLoad(dllname.into_param().abi(), dllpath.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn ImageNtHeader(base: *const ::core::ffi::c_void) -> *mut IMAGE_NT_HEADERS64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageNtHeader(base: *const ::core::ffi::c_void) -> *mut IMAGE_NT_HEADERS64;
}
::core::mem::transmute(ImageNtHeader(::core::mem::transmute(base)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[inline]
pub unsafe fn ImageNtHeader(base: *const ::core::ffi::c_void) -> *mut IMAGE_NT_HEADERS32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageNtHeader(base: *const ::core::ffi::c_void) -> *mut IMAGE_NT_HEADERS32;
}
::core::mem::transmute(ImageNtHeader(::core::mem::transmute(base)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ImageRemoveCertificate<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, index: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageRemoveCertificate(filehandle: super::super::super::Foundation::HANDLE, index: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageRemoveCertificate(filehandle.into_param().abi(), ::core::mem::transmute(index)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn ImageRvaToSection(ntheaders: *const IMAGE_NT_HEADERS64, base: *const ::core::ffi::c_void, rva: u32) -> *mut IMAGE_SECTION_HEADER {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageRvaToSection(ntheaders: *const IMAGE_NT_HEADERS64, base: *const ::core::ffi::c_void, rva: u32) -> *mut IMAGE_SECTION_HEADER;
}
::core::mem::transmute(ImageRvaToSection(::core::mem::transmute(ntheaders), ::core::mem::transmute(base), ::core::mem::transmute(rva)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[inline]
pub unsafe fn ImageRvaToSection(ntheaders: *const IMAGE_NT_HEADERS32, base: *const ::core::ffi::c_void, rva: u32) -> *mut IMAGE_SECTION_HEADER {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageRvaToSection(ntheaders: *const IMAGE_NT_HEADERS32, base: *const ::core::ffi::c_void, rva: u32) -> *mut IMAGE_SECTION_HEADER;
}
::core::mem::transmute(ImageRvaToSection(::core::mem::transmute(ntheaders), ::core::mem::transmute(base), ::core::mem::transmute(rva)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn ImageRvaToVa(ntheaders: *const IMAGE_NT_HEADERS64, base: *const ::core::ffi::c_void, rva: u32, lastrvasection: *const *const IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageRvaToVa(ntheaders: *const IMAGE_NT_HEADERS64, base: *const ::core::ffi::c_void, rva: u32, lastrvasection: *const *const IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(ImageRvaToVa(::core::mem::transmute(ntheaders), ::core::mem::transmute(base), ::core::mem::transmute(rva), ::core::mem::transmute(lastrvasection)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[inline]
pub unsafe fn ImageRvaToVa(ntheaders: *const IMAGE_NT_HEADERS32, base: *const ::core::ffi::c_void, rva: u32, lastrvasection: *const *const IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageRvaToVa(ntheaders: *const IMAGE_NT_HEADERS32, base: *const ::core::ffi::c_void, rva: u32, lastrvasection: *const *const IMAGE_SECTION_HEADER) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(ImageRvaToVa(::core::mem::transmute(ntheaders), ::core::mem::transmute(base), ::core::mem::transmute(rva), ::core::mem::transmute(lastrvasection)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn ImageUnload(loadedimage: *mut LOADED_IMAGE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImageUnload(loadedimage: *mut LOADED_IMAGE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ImageUnload(::core::mem::transmute(loadedimage)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn ImagehlpApiVersion() -> *mut API_VERSION {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImagehlpApiVersion() -> *mut API_VERSION;
}
::core::mem::transmute(ImagehlpApiVersion())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn ImagehlpApiVersionEx(appversion: *const API_VERSION) -> *mut API_VERSION {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ImagehlpApiVersionEx(appversion: *const API_VERSION) -> *mut API_VERSION;
}
::core::mem::transmute(ImagehlpApiVersionEx(::core::mem::transmute(appversion)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn InitializeContext(buffer: *mut ::core::ffi::c_void, contextflags: u32, context: *mut *mut CONTEXT, contextlength: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn InitializeContext(buffer: *mut ::core::ffi::c_void, contextflags: u32, context: *mut *mut CONTEXT, contextlength: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(InitializeContext(::core::mem::transmute(buffer), ::core::mem::transmute(contextflags), ::core::mem::transmute(context), ::core::mem::transmute(contextlength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn InitializeContext2(buffer: *mut ::core::ffi::c_void, contextflags: u32, context: *mut *mut CONTEXT, contextlength: *mut u32, xstatecompactionmask: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn InitializeContext2(buffer: *mut ::core::ffi::c_void, contextflags: u32, context: *mut *mut CONTEXT, contextlength: *mut u32, xstatecompactionmask: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(InitializeContext2(::core::mem::transmute(buffer), ::core::mem::transmute(contextflags), ::core::mem::transmute(context), ::core::mem::transmute(contextlength), ::core::mem::transmute(xstatecompactionmask)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct IntrinsicKind(pub i32);
pub const IntrinsicVoid: IntrinsicKind = IntrinsicKind(0i32);
pub const IntrinsicBool: IntrinsicKind = IntrinsicKind(1i32);
pub const IntrinsicChar: IntrinsicKind = IntrinsicKind(2i32);
pub const IntrinsicWChar: IntrinsicKind = IntrinsicKind(3i32);
pub const IntrinsicInt: IntrinsicKind = IntrinsicKind(4i32);
pub const IntrinsicUInt: IntrinsicKind = IntrinsicKind(5i32);
pub const IntrinsicLong: IntrinsicKind = IntrinsicKind(6i32);
pub const IntrinsicULong: IntrinsicKind = IntrinsicKind(7i32);
pub const IntrinsicFloat: IntrinsicKind = IntrinsicKind(8i32);
pub const IntrinsicHRESULT: IntrinsicKind = IntrinsicKind(9i32);
pub const IntrinsicChar16: IntrinsicKind = IntrinsicKind(10i32);
pub const IntrinsicChar32: IntrinsicKind = IntrinsicKind(11i32);
impl ::core::convert::From<i32> for IntrinsicKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for IntrinsicKind {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn IsDebuggerPresent() -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn IsDebuggerPresent() -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(IsDebuggerPresent())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct JS_PROPERTY_ATTRIBUTES(pub i32);
pub const JS_PROPERTY_ATTRIBUTE_NONE: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(0i32);
pub const JS_PROPERTY_HAS_CHILDREN: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(1i32);
pub const JS_PROPERTY_FAKE: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(2i32);
pub const JS_PROPERTY_METHOD: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(4i32);
pub const JS_PROPERTY_READONLY: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(8i32);
pub const JS_PROPERTY_NATIVE_WINRT_POINTER: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(16i32);
pub const JS_PROPERTY_FRAME_INTRYBLOCK: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(32i32);
pub const JS_PROPERTY_FRAME_INCATCHBLOCK: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(64i32);
pub const JS_PROPERTY_FRAME_INFINALLYBLOCK: JS_PROPERTY_ATTRIBUTES = JS_PROPERTY_ATTRIBUTES(128i32);
impl ::core::convert::From<i32> for JS_PROPERTY_ATTRIBUTES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for JS_PROPERTY_ATTRIBUTES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct JS_PROPERTY_MEMBERS(pub i32);
pub const JS_PROPERTY_MEMBERS_ALL: JS_PROPERTY_MEMBERS = JS_PROPERTY_MEMBERS(0i32);
pub const JS_PROPERTY_MEMBERS_ARGUMENTS: JS_PROPERTY_MEMBERS = JS_PROPERTY_MEMBERS(1i32);
impl ::core::convert::From<i32> for JS_PROPERTY_MEMBERS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for JS_PROPERTY_MEMBERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct JsDebugPropertyInfo {
pub name: super::super::super::Foundation::BSTR,
pub r#type: super::super::super::Foundation::BSTR,
pub value: super::super::super::Foundation::BSTR,
pub fullName: super::super::super::Foundation::BSTR,
pub attr: JS_PROPERTY_ATTRIBUTES,
}
#[cfg(feature = "Win32_Foundation")]
impl JsDebugPropertyInfo {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for JsDebugPropertyInfo {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for JsDebugPropertyInfo {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("JsDebugPropertyInfo").field("name", &self.name).field("r#type", &self.r#type).field("value", &self.value).field("fullName", &self.fullName).field("attr", &self.attr).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for JsDebugPropertyInfo {
fn eq(&self, other: &Self) -> bool {
self.name == other.name && self.r#type == other.r#type && self.value == other.value && self.fullName == other.fullName && self.attr == other.attr
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for JsDebugPropertyInfo {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for JsDebugPropertyInfo {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct JsDebugReadMemoryFlags(pub i32);
pub const None: JsDebugReadMemoryFlags = JsDebugReadMemoryFlags(0i32);
pub const JsDebugAllowPartialRead: JsDebugReadMemoryFlags = JsDebugReadMemoryFlags(1i32);
impl ::core::convert::From<i32> for JsDebugReadMemoryFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for JsDebugReadMemoryFlags {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_System_Kernel")]
pub struct KDDEBUGGER_DATA32 {
pub Header: DBGKD_DEBUG_DATA_HEADER32,
pub KernBase: u32,
pub BreakpointWithStatus: u32,
pub SavedContext: u32,
pub ThCallbackStack: u16,
pub NextCallback: u16,
pub FramePointer: u16,
pub _bitfield: u16,
pub KiCallUserMode: u32,
pub KeUserCallbackDispatcher: u32,
pub PsLoadedModuleList: u32,
pub PsActiveProcessHead: u32,
pub PspCidTable: u32,
pub ExpSystemResourcesList: u32,
pub ExpPagedPoolDescriptor: u32,
pub ExpNumberOfPagedPools: u32,
pub KeTimeIncrement: u32,
pub KeBugCheckCallbackListHead: u32,
pub KiBugcheckData: u32,
pub IopErrorLogListHead: u32,
pub ObpRootDirectoryObject: u32,
pub ObpTypeObjectType: u32,
pub MmSystemCacheStart: u32,
pub MmSystemCacheEnd: u32,
pub MmSystemCacheWs: u32,
pub MmPfnDatabase: u32,
pub MmSystemPtesStart: u32,
pub MmSystemPtesEnd: u32,
pub MmSubsectionBase: u32,
pub MmNumberOfPagingFiles: u32,
pub MmLowestPhysicalPage: u32,
pub MmHighestPhysicalPage: u32,
pub MmNumberOfPhysicalPages: u32,
pub MmMaximumNonPagedPoolInBytes: u32,
pub MmNonPagedSystemStart: u32,
pub MmNonPagedPoolStart: u32,
pub MmNonPagedPoolEnd: u32,
pub MmPagedPoolStart: u32,
pub MmPagedPoolEnd: u32,
pub MmPagedPoolInformation: u32,
pub MmPageSize: u32,
pub MmSizeOfPagedPoolInBytes: u32,
pub MmTotalCommitLimit: u32,
pub MmTotalCommittedPages: u32,
pub MmSharedCommit: u32,
pub MmDriverCommit: u32,
pub MmProcessCommit: u32,
pub MmPagedPoolCommit: u32,
pub MmExtendedCommit: u32,
pub MmZeroedPageListHead: u32,
pub MmFreePageListHead: u32,
pub MmStandbyPageListHead: u32,
pub MmModifiedPageListHead: u32,
pub MmModifiedNoWritePageListHead: u32,
pub MmAvailablePages: u32,
pub MmResidentAvailablePages: u32,
pub PoolTrackTable: u32,
pub NonPagedPoolDescriptor: u32,
pub MmHighestUserAddress: u32,
pub MmSystemRangeStart: u32,
pub MmUserProbeAddress: u32,
pub KdPrintCircularBuffer: u32,
pub KdPrintCircularBufferEnd: u32,
pub KdPrintWritePointer: u32,
pub KdPrintRolloverCount: u32,
pub MmLoadedUserImageList: u32,
}
#[cfg(feature = "Win32_System_Kernel")]
impl KDDEBUGGER_DATA32 {}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for KDDEBUGGER_DATA32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for KDDEBUGGER_DATA32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KDDEBUGGER_DATA32")
.field("Header", &self.Header)
.field("KernBase", &self.KernBase)
.field("BreakpointWithStatus", &self.BreakpointWithStatus)
.field("SavedContext", &self.SavedContext)
.field("ThCallbackStack", &self.ThCallbackStack)
.field("NextCallback", &self.NextCallback)
.field("FramePointer", &self.FramePointer)
.field("_bitfield", &self._bitfield)
.field("KiCallUserMode", &self.KiCallUserMode)
.field("KeUserCallbackDispatcher", &self.KeUserCallbackDispatcher)
.field("PsLoadedModuleList", &self.PsLoadedModuleList)
.field("PsActiveProcessHead", &self.PsActiveProcessHead)
.field("PspCidTable", &self.PspCidTable)
.field("ExpSystemResourcesList", &self.ExpSystemResourcesList)
.field("ExpPagedPoolDescriptor", &self.ExpPagedPoolDescriptor)
.field("ExpNumberOfPagedPools", &self.ExpNumberOfPagedPools)
.field("KeTimeIncrement", &self.KeTimeIncrement)
.field("KeBugCheckCallbackListHead", &self.KeBugCheckCallbackListHead)
.field("KiBugcheckData", &self.KiBugcheckData)
.field("IopErrorLogListHead", &self.IopErrorLogListHead)
.field("ObpRootDirectoryObject", &self.ObpRootDirectoryObject)
.field("ObpTypeObjectType", &self.ObpTypeObjectType)
.field("MmSystemCacheStart", &self.MmSystemCacheStart)
.field("MmSystemCacheEnd", &self.MmSystemCacheEnd)
.field("MmSystemCacheWs", &self.MmSystemCacheWs)
.field("MmPfnDatabase", &self.MmPfnDatabase)
.field("MmSystemPtesStart", &self.MmSystemPtesStart)
.field("MmSystemPtesEnd", &self.MmSystemPtesEnd)
.field("MmSubsectionBase", &self.MmSubsectionBase)
.field("MmNumberOfPagingFiles", &self.MmNumberOfPagingFiles)
.field("MmLowestPhysicalPage", &self.MmLowestPhysicalPage)
.field("MmHighestPhysicalPage", &self.MmHighestPhysicalPage)
.field("MmNumberOfPhysicalPages", &self.MmNumberOfPhysicalPages)
.field("MmMaximumNonPagedPoolInBytes", &self.MmMaximumNonPagedPoolInBytes)
.field("MmNonPagedSystemStart", &self.MmNonPagedSystemStart)
.field("MmNonPagedPoolStart", &self.MmNonPagedPoolStart)
.field("MmNonPagedPoolEnd", &self.MmNonPagedPoolEnd)
.field("MmPagedPoolStart", &self.MmPagedPoolStart)
.field("MmPagedPoolEnd", &self.MmPagedPoolEnd)
.field("MmPagedPoolInformation", &self.MmPagedPoolInformation)
.field("MmPageSize", &self.MmPageSize)
.field("MmSizeOfPagedPoolInBytes", &self.MmSizeOfPagedPoolInBytes)
.field("MmTotalCommitLimit", &self.MmTotalCommitLimit)
.field("MmTotalCommittedPages", &self.MmTotalCommittedPages)
.field("MmSharedCommit", &self.MmSharedCommit)
.field("MmDriverCommit", &self.MmDriverCommit)
.field("MmProcessCommit", &self.MmProcessCommit)
.field("MmPagedPoolCommit", &self.MmPagedPoolCommit)
.field("MmExtendedCommit", &self.MmExtendedCommit)
.field("MmZeroedPageListHead", &self.MmZeroedPageListHead)
.field("MmFreePageListHead", &self.MmFreePageListHead)
.field("MmStandbyPageListHead", &self.MmStandbyPageListHead)
.field("MmModifiedPageListHead", &self.MmModifiedPageListHead)
.field("MmModifiedNoWritePageListHead", &self.MmModifiedNoWritePageListHead)
.field("MmAvailablePages", &self.MmAvailablePages)
.field("MmResidentAvailablePages", &self.MmResidentAvailablePages)
.field("PoolTrackTable", &self.PoolTrackTable)
.field("NonPagedPoolDescriptor", &self.NonPagedPoolDescriptor)
.field("MmHighestUserAddress", &self.MmHighestUserAddress)
.field("MmSystemRangeStart", &self.MmSystemRangeStart)
.field("MmUserProbeAddress", &self.MmUserProbeAddress)
.field("KdPrintCircularBuffer", &self.KdPrintCircularBuffer)
.field("KdPrintCircularBufferEnd", &self.KdPrintCircularBufferEnd)
.field("KdPrintWritePointer", &self.KdPrintWritePointer)
.field("KdPrintRolloverCount", &self.KdPrintRolloverCount)
.field("MmLoadedUserImageList", &self.MmLoadedUserImageList)
.finish()
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for KDDEBUGGER_DATA32 {
fn eq(&self, other: &Self) -> bool {
self.Header == other.Header
&& self.KernBase == other.KernBase
&& self.BreakpointWithStatus == other.BreakpointWithStatus
&& self.SavedContext == other.SavedContext
&& self.ThCallbackStack == other.ThCallbackStack
&& self.NextCallback == other.NextCallback
&& self.FramePointer == other.FramePointer
&& self._bitfield == other._bitfield
&& self.KiCallUserMode == other.KiCallUserMode
&& self.KeUserCallbackDispatcher == other.KeUserCallbackDispatcher
&& self.PsLoadedModuleList == other.PsLoadedModuleList
&& self.PsActiveProcessHead == other.PsActiveProcessHead
&& self.PspCidTable == other.PspCidTable
&& self.ExpSystemResourcesList == other.ExpSystemResourcesList
&& self.ExpPagedPoolDescriptor == other.ExpPagedPoolDescriptor
&& self.ExpNumberOfPagedPools == other.ExpNumberOfPagedPools
&& self.KeTimeIncrement == other.KeTimeIncrement
&& self.KeBugCheckCallbackListHead == other.KeBugCheckCallbackListHead
&& self.KiBugcheckData == other.KiBugcheckData
&& self.IopErrorLogListHead == other.IopErrorLogListHead
&& self.ObpRootDirectoryObject == other.ObpRootDirectoryObject
&& self.ObpTypeObjectType == other.ObpTypeObjectType
&& self.MmSystemCacheStart == other.MmSystemCacheStart
&& self.MmSystemCacheEnd == other.MmSystemCacheEnd
&& self.MmSystemCacheWs == other.MmSystemCacheWs
&& self.MmPfnDatabase == other.MmPfnDatabase
&& self.MmSystemPtesStart == other.MmSystemPtesStart
&& self.MmSystemPtesEnd == other.MmSystemPtesEnd
&& self.MmSubsectionBase == other.MmSubsectionBase
&& self.MmNumberOfPagingFiles == other.MmNumberOfPagingFiles
&& self.MmLowestPhysicalPage == other.MmLowestPhysicalPage
&& self.MmHighestPhysicalPage == other.MmHighestPhysicalPage
&& self.MmNumberOfPhysicalPages == other.MmNumberOfPhysicalPages
&& self.MmMaximumNonPagedPoolInBytes == other.MmMaximumNonPagedPoolInBytes
&& self.MmNonPagedSystemStart == other.MmNonPagedSystemStart
&& self.MmNonPagedPoolStart == other.MmNonPagedPoolStart
&& self.MmNonPagedPoolEnd == other.MmNonPagedPoolEnd
&& self.MmPagedPoolStart == other.MmPagedPoolStart
&& self.MmPagedPoolEnd == other.MmPagedPoolEnd
&& self.MmPagedPoolInformation == other.MmPagedPoolInformation
&& self.MmPageSize == other.MmPageSize
&& self.MmSizeOfPagedPoolInBytes == other.MmSizeOfPagedPoolInBytes
&& self.MmTotalCommitLimit == other.MmTotalCommitLimit
&& self.MmTotalCommittedPages == other.MmTotalCommittedPages
&& self.MmSharedCommit == other.MmSharedCommit
&& self.MmDriverCommit == other.MmDriverCommit
&& self.MmProcessCommit == other.MmProcessCommit
&& self.MmPagedPoolCommit == other.MmPagedPoolCommit
&& self.MmExtendedCommit == other.MmExtendedCommit
&& self.MmZeroedPageListHead == other.MmZeroedPageListHead
&& self.MmFreePageListHead == other.MmFreePageListHead
&& self.MmStandbyPageListHead == other.MmStandbyPageListHead
&& self.MmModifiedPageListHead == other.MmModifiedPageListHead
&& self.MmModifiedNoWritePageListHead == other.MmModifiedNoWritePageListHead
&& self.MmAvailablePages == other.MmAvailablePages
&& self.MmResidentAvailablePages == other.MmResidentAvailablePages
&& self.PoolTrackTable == other.PoolTrackTable
&& self.NonPagedPoolDescriptor == other.NonPagedPoolDescriptor
&& self.MmHighestUserAddress == other.MmHighestUserAddress
&& self.MmSystemRangeStart == other.MmSystemRangeStart
&& self.MmUserProbeAddress == other.MmUserProbeAddress
&& self.KdPrintCircularBuffer == other.KdPrintCircularBuffer
&& self.KdPrintCircularBufferEnd == other.KdPrintCircularBufferEnd
&& self.KdPrintWritePointer == other.KdPrintWritePointer
&& self.KdPrintRolloverCount == other.KdPrintRolloverCount
&& self.MmLoadedUserImageList == other.MmLoadedUserImageList
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for KDDEBUGGER_DATA32 {}
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for KDDEBUGGER_DATA32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_System_Kernel")]
pub struct KDDEBUGGER_DATA64 {
pub Header: DBGKD_DEBUG_DATA_HEADER64,
pub KernBase: u64,
pub BreakpointWithStatus: u64,
pub SavedContext: u64,
pub ThCallbackStack: u16,
pub NextCallback: u16,
pub FramePointer: u16,
pub _bitfield: u16,
pub KiCallUserMode: u64,
pub KeUserCallbackDispatcher: u64,
pub PsLoadedModuleList: u64,
pub PsActiveProcessHead: u64,
pub PspCidTable: u64,
pub ExpSystemResourcesList: u64,
pub ExpPagedPoolDescriptor: u64,
pub ExpNumberOfPagedPools: u64,
pub KeTimeIncrement: u64,
pub KeBugCheckCallbackListHead: u64,
pub KiBugcheckData: u64,
pub IopErrorLogListHead: u64,
pub ObpRootDirectoryObject: u64,
pub ObpTypeObjectType: u64,
pub MmSystemCacheStart: u64,
pub MmSystemCacheEnd: u64,
pub MmSystemCacheWs: u64,
pub MmPfnDatabase: u64,
pub MmSystemPtesStart: u64,
pub MmSystemPtesEnd: u64,
pub MmSubsectionBase: u64,
pub MmNumberOfPagingFiles: u64,
pub MmLowestPhysicalPage: u64,
pub MmHighestPhysicalPage: u64,
pub MmNumberOfPhysicalPages: u64,
pub MmMaximumNonPagedPoolInBytes: u64,
pub MmNonPagedSystemStart: u64,
pub MmNonPagedPoolStart: u64,
pub MmNonPagedPoolEnd: u64,
pub MmPagedPoolStart: u64,
pub MmPagedPoolEnd: u64,
pub MmPagedPoolInformation: u64,
pub MmPageSize: u64,
pub MmSizeOfPagedPoolInBytes: u64,
pub MmTotalCommitLimit: u64,
pub MmTotalCommittedPages: u64,
pub MmSharedCommit: u64,
pub MmDriverCommit: u64,
pub MmProcessCommit: u64,
pub MmPagedPoolCommit: u64,
pub MmExtendedCommit: u64,
pub MmZeroedPageListHead: u64,
pub MmFreePageListHead: u64,
pub MmStandbyPageListHead: u64,
pub MmModifiedPageListHead: u64,
pub MmModifiedNoWritePageListHead: u64,
pub MmAvailablePages: u64,
pub MmResidentAvailablePages: u64,
pub PoolTrackTable: u64,
pub NonPagedPoolDescriptor: u64,
pub MmHighestUserAddress: u64,
pub MmSystemRangeStart: u64,
pub MmUserProbeAddress: u64,
pub KdPrintCircularBuffer: u64,
pub KdPrintCircularBufferEnd: u64,
pub KdPrintWritePointer: u64,
pub KdPrintRolloverCount: u64,
pub MmLoadedUserImageList: u64,
pub NtBuildLab: u64,
pub KiNormalSystemCall: u64,
pub KiProcessorBlock: u64,
pub MmUnloadedDrivers: u64,
pub MmLastUnloadedDriver: u64,
pub MmTriageActionTaken: u64,
pub MmSpecialPoolTag: u64,
pub KernelVerifier: u64,
pub MmVerifierData: u64,
pub MmAllocatedNonPagedPool: u64,
pub MmPeakCommitment: u64,
pub MmTotalCommitLimitMaximum: u64,
pub CmNtCSDVersion: u64,
pub MmPhysicalMemoryBlock: u64,
pub MmSessionBase: u64,
pub MmSessionSize: u64,
pub MmSystemParentTablePage: u64,
pub MmVirtualTranslationBase: u64,
pub OffsetKThreadNextProcessor: u16,
pub OffsetKThreadTeb: u16,
pub OffsetKThreadKernelStack: u16,
pub OffsetKThreadInitialStack: u16,
pub OffsetKThreadApcProcess: u16,
pub OffsetKThreadState: u16,
pub OffsetKThreadBStore: u16,
pub OffsetKThreadBStoreLimit: u16,
pub SizeEProcess: u16,
pub OffsetEprocessPeb: u16,
pub OffsetEprocessParentCID: u16,
pub OffsetEprocessDirectoryTableBase: u16,
pub SizePrcb: u16,
pub OffsetPrcbDpcRoutine: u16,
pub OffsetPrcbCurrentThread: u16,
pub OffsetPrcbMhz: u16,
pub OffsetPrcbCpuType: u16,
pub OffsetPrcbVendorString: u16,
pub OffsetPrcbProcStateContext: u16,
pub OffsetPrcbNumber: u16,
pub SizeEThread: u16,
pub L1tfHighPhysicalBitIndex: u8,
pub L1tfSwizzleBitIndex: u8,
pub Padding0: u32,
pub KdPrintCircularBufferPtr: u64,
pub KdPrintBufferSize: u64,
pub KeLoaderBlock: u64,
pub SizePcr: u16,
pub OffsetPcrSelfPcr: u16,
pub OffsetPcrCurrentPrcb: u16,
pub OffsetPcrContainedPrcb: u16,
pub OffsetPcrInitialBStore: u16,
pub OffsetPcrBStoreLimit: u16,
pub OffsetPcrInitialStack: u16,
pub OffsetPcrStackLimit: u16,
pub OffsetPrcbPcrPage: u16,
pub OffsetPrcbProcStateSpecialReg: u16,
pub GdtR0Code: u16,
pub GdtR0Data: u16,
pub GdtR0Pcr: u16,
pub GdtR3Code: u16,
pub GdtR3Data: u16,
pub GdtR3Teb: u16,
pub GdtLdt: u16,
pub GdtTss: u16,
pub Gdt64R3CmCode: u16,
pub Gdt64R3CmTeb: u16,
pub IopNumTriageDumpDataBlocks: u64,
pub IopTriageDumpDataBlocks: u64,
pub VfCrashDataBlock: u64,
pub MmBadPagesDetected: u64,
pub MmZeroedPageSingleBitErrorsDetected: u64,
pub EtwpDebuggerData: u64,
pub OffsetPrcbContext: u16,
pub OffsetPrcbMaxBreakpoints: u16,
pub OffsetPrcbMaxWatchpoints: u16,
pub OffsetKThreadStackLimit: u32,
pub OffsetKThreadStackBase: u32,
pub OffsetKThreadQueueListEntry: u32,
pub OffsetEThreadIrpList: u32,
pub OffsetPrcbIdleThread: u16,
pub OffsetPrcbNormalDpcState: u16,
pub OffsetPrcbDpcStack: u16,
pub OffsetPrcbIsrStack: u16,
pub SizeKDPC_STACK_FRAME: u16,
pub OffsetKPriQueueThreadListHead: u16,
pub OffsetKThreadWaitReason: u16,
pub Padding1: u16,
pub PteBase: u64,
pub RetpolineStubFunctionTable: u64,
pub RetpolineStubFunctionTableSize: u32,
pub RetpolineStubOffset: u32,
pub RetpolineStubSize: u32,
pub OffsetEProcessMmHotPatchContext: u16,
}
#[cfg(feature = "Win32_System_Kernel")]
impl KDDEBUGGER_DATA64 {}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::default::Default for KDDEBUGGER_DATA64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::fmt::Debug for KDDEBUGGER_DATA64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KDDEBUGGER_DATA64")
.field("Header", &self.Header)
.field("KernBase", &self.KernBase)
.field("BreakpointWithStatus", &self.BreakpointWithStatus)
.field("SavedContext", &self.SavedContext)
.field("ThCallbackStack", &self.ThCallbackStack)
.field("NextCallback", &self.NextCallback)
.field("FramePointer", &self.FramePointer)
.field("_bitfield", &self._bitfield)
.field("KiCallUserMode", &self.KiCallUserMode)
.field("KeUserCallbackDispatcher", &self.KeUserCallbackDispatcher)
.field("PsLoadedModuleList", &self.PsLoadedModuleList)
.field("PsActiveProcessHead", &self.PsActiveProcessHead)
.field("PspCidTable", &self.PspCidTable)
.field("ExpSystemResourcesList", &self.ExpSystemResourcesList)
.field("ExpPagedPoolDescriptor", &self.ExpPagedPoolDescriptor)
.field("ExpNumberOfPagedPools", &self.ExpNumberOfPagedPools)
.field("KeTimeIncrement", &self.KeTimeIncrement)
.field("KeBugCheckCallbackListHead", &self.KeBugCheckCallbackListHead)
.field("KiBugcheckData", &self.KiBugcheckData)
.field("IopErrorLogListHead", &self.IopErrorLogListHead)
.field("ObpRootDirectoryObject", &self.ObpRootDirectoryObject)
.field("ObpTypeObjectType", &self.ObpTypeObjectType)
.field("MmSystemCacheStart", &self.MmSystemCacheStart)
.field("MmSystemCacheEnd", &self.MmSystemCacheEnd)
.field("MmSystemCacheWs", &self.MmSystemCacheWs)
.field("MmPfnDatabase", &self.MmPfnDatabase)
.field("MmSystemPtesStart", &self.MmSystemPtesStart)
.field("MmSystemPtesEnd", &self.MmSystemPtesEnd)
.field("MmSubsectionBase", &self.MmSubsectionBase)
.field("MmNumberOfPagingFiles", &self.MmNumberOfPagingFiles)
.field("MmLowestPhysicalPage", &self.MmLowestPhysicalPage)
.field("MmHighestPhysicalPage", &self.MmHighestPhysicalPage)
.field("MmNumberOfPhysicalPages", &self.MmNumberOfPhysicalPages)
.field("MmMaximumNonPagedPoolInBytes", &self.MmMaximumNonPagedPoolInBytes)
.field("MmNonPagedSystemStart", &self.MmNonPagedSystemStart)
.field("MmNonPagedPoolStart", &self.MmNonPagedPoolStart)
.field("MmNonPagedPoolEnd", &self.MmNonPagedPoolEnd)
.field("MmPagedPoolStart", &self.MmPagedPoolStart)
.field("MmPagedPoolEnd", &self.MmPagedPoolEnd)
.field("MmPagedPoolInformation", &self.MmPagedPoolInformation)
.field("MmPageSize", &self.MmPageSize)
.field("MmSizeOfPagedPoolInBytes", &self.MmSizeOfPagedPoolInBytes)
.field("MmTotalCommitLimit", &self.MmTotalCommitLimit)
.field("MmTotalCommittedPages", &self.MmTotalCommittedPages)
.field("MmSharedCommit", &self.MmSharedCommit)
.field("MmDriverCommit", &self.MmDriverCommit)
.field("MmProcessCommit", &self.MmProcessCommit)
.field("MmPagedPoolCommit", &self.MmPagedPoolCommit)
.field("MmExtendedCommit", &self.MmExtendedCommit)
.field("MmZeroedPageListHead", &self.MmZeroedPageListHead)
.field("MmFreePageListHead", &self.MmFreePageListHead)
.field("MmStandbyPageListHead", &self.MmStandbyPageListHead)
.field("MmModifiedPageListHead", &self.MmModifiedPageListHead)
.field("MmModifiedNoWritePageListHead", &self.MmModifiedNoWritePageListHead)
.field("MmAvailablePages", &self.MmAvailablePages)
.field("MmResidentAvailablePages", &self.MmResidentAvailablePages)
.field("PoolTrackTable", &self.PoolTrackTable)
.field("NonPagedPoolDescriptor", &self.NonPagedPoolDescriptor)
.field("MmHighestUserAddress", &self.MmHighestUserAddress)
.field("MmSystemRangeStart", &self.MmSystemRangeStart)
.field("MmUserProbeAddress", &self.MmUserProbeAddress)
.field("KdPrintCircularBuffer", &self.KdPrintCircularBuffer)
.field("KdPrintCircularBufferEnd", &self.KdPrintCircularBufferEnd)
.field("KdPrintWritePointer", &self.KdPrintWritePointer)
.field("KdPrintRolloverCount", &self.KdPrintRolloverCount)
.field("MmLoadedUserImageList", &self.MmLoadedUserImageList)
.field("NtBuildLab", &self.NtBuildLab)
.field("KiNormalSystemCall", &self.KiNormalSystemCall)
.field("KiProcessorBlock", &self.KiProcessorBlock)
.field("MmUnloadedDrivers", &self.MmUnloadedDrivers)
.field("MmLastUnloadedDriver", &self.MmLastUnloadedDriver)
.field("MmTriageActionTaken", &self.MmTriageActionTaken)
.field("MmSpecialPoolTag", &self.MmSpecialPoolTag)
.field("KernelVerifier", &self.KernelVerifier)
.field("MmVerifierData", &self.MmVerifierData)
.field("MmAllocatedNonPagedPool", &self.MmAllocatedNonPagedPool)
.field("MmPeakCommitment", &self.MmPeakCommitment)
.field("MmTotalCommitLimitMaximum", &self.MmTotalCommitLimitMaximum)
.field("CmNtCSDVersion", &self.CmNtCSDVersion)
.field("MmPhysicalMemoryBlock", &self.MmPhysicalMemoryBlock)
.field("MmSessionBase", &self.MmSessionBase)
.field("MmSessionSize", &self.MmSessionSize)
.field("MmSystemParentTablePage", &self.MmSystemParentTablePage)
.field("MmVirtualTranslationBase", &self.MmVirtualTranslationBase)
.field("OffsetKThreadNextProcessor", &self.OffsetKThreadNextProcessor)
.field("OffsetKThreadTeb", &self.OffsetKThreadTeb)
.field("OffsetKThreadKernelStack", &self.OffsetKThreadKernelStack)
.field("OffsetKThreadInitialStack", &self.OffsetKThreadInitialStack)
.field("OffsetKThreadApcProcess", &self.OffsetKThreadApcProcess)
.field("OffsetKThreadState", &self.OffsetKThreadState)
.field("OffsetKThreadBStore", &self.OffsetKThreadBStore)
.field("OffsetKThreadBStoreLimit", &self.OffsetKThreadBStoreLimit)
.field("SizeEProcess", &self.SizeEProcess)
.field("OffsetEprocessPeb", &self.OffsetEprocessPeb)
.field("OffsetEprocessParentCID", &self.OffsetEprocessParentCID)
.field("OffsetEprocessDirectoryTableBase", &self.OffsetEprocessDirectoryTableBase)
.field("SizePrcb", &self.SizePrcb)
.field("OffsetPrcbDpcRoutine", &self.OffsetPrcbDpcRoutine)
.field("OffsetPrcbCurrentThread", &self.OffsetPrcbCurrentThread)
.field("OffsetPrcbMhz", &self.OffsetPrcbMhz)
.field("OffsetPrcbCpuType", &self.OffsetPrcbCpuType)
.field("OffsetPrcbVendorString", &self.OffsetPrcbVendorString)
.field("OffsetPrcbProcStateContext", &self.OffsetPrcbProcStateContext)
.field("OffsetPrcbNumber", &self.OffsetPrcbNumber)
.field("SizeEThread", &self.SizeEThread)
.field("L1tfHighPhysicalBitIndex", &self.L1tfHighPhysicalBitIndex)
.field("L1tfSwizzleBitIndex", &self.L1tfSwizzleBitIndex)
.field("Padding0", &self.Padding0)
.field("KdPrintCircularBufferPtr", &self.KdPrintCircularBufferPtr)
.field("KdPrintBufferSize", &self.KdPrintBufferSize)
.field("KeLoaderBlock", &self.KeLoaderBlock)
.field("SizePcr", &self.SizePcr)
.field("OffsetPcrSelfPcr", &self.OffsetPcrSelfPcr)
.field("OffsetPcrCurrentPrcb", &self.OffsetPcrCurrentPrcb)
.field("OffsetPcrContainedPrcb", &self.OffsetPcrContainedPrcb)
.field("OffsetPcrInitialBStore", &self.OffsetPcrInitialBStore)
.field("OffsetPcrBStoreLimit", &self.OffsetPcrBStoreLimit)
.field("OffsetPcrInitialStack", &self.OffsetPcrInitialStack)
.field("OffsetPcrStackLimit", &self.OffsetPcrStackLimit)
.field("OffsetPrcbPcrPage", &self.OffsetPrcbPcrPage)
.field("OffsetPrcbProcStateSpecialReg", &self.OffsetPrcbProcStateSpecialReg)
.field("GdtR0Code", &self.GdtR0Code)
.field("GdtR0Data", &self.GdtR0Data)
.field("GdtR0Pcr", &self.GdtR0Pcr)
.field("GdtR3Code", &self.GdtR3Code)
.field("GdtR3Data", &self.GdtR3Data)
.field("GdtR3Teb", &self.GdtR3Teb)
.field("GdtLdt", &self.GdtLdt)
.field("GdtTss", &self.GdtTss)
.field("Gdt64R3CmCode", &self.Gdt64R3CmCode)
.field("Gdt64R3CmTeb", &self.Gdt64R3CmTeb)
.field("IopNumTriageDumpDataBlocks", &self.IopNumTriageDumpDataBlocks)
.field("IopTriageDumpDataBlocks", &self.IopTriageDumpDataBlocks)
.field("VfCrashDataBlock", &self.VfCrashDataBlock)
.field("MmBadPagesDetected", &self.MmBadPagesDetected)
.field("MmZeroedPageSingleBitErrorsDetected", &self.MmZeroedPageSingleBitErrorsDetected)
.field("EtwpDebuggerData", &self.EtwpDebuggerData)
.field("OffsetPrcbContext", &self.OffsetPrcbContext)
.field("OffsetPrcbMaxBreakpoints", &self.OffsetPrcbMaxBreakpoints)
.field("OffsetPrcbMaxWatchpoints", &self.OffsetPrcbMaxWatchpoints)
.field("OffsetKThreadStackLimit", &self.OffsetKThreadStackLimit)
.field("OffsetKThreadStackBase", &self.OffsetKThreadStackBase)
.field("OffsetKThreadQueueListEntry", &self.OffsetKThreadQueueListEntry)
.field("OffsetEThreadIrpList", &self.OffsetEThreadIrpList)
.field("OffsetPrcbIdleThread", &self.OffsetPrcbIdleThread)
.field("OffsetPrcbNormalDpcState", &self.OffsetPrcbNormalDpcState)
.field("OffsetPrcbDpcStack", &self.OffsetPrcbDpcStack)
.field("OffsetPrcbIsrStack", &self.OffsetPrcbIsrStack)
.field("SizeKDPC_STACK_FRAME", &self.SizeKDPC_STACK_FRAME)
.field("OffsetKPriQueueThreadListHead", &self.OffsetKPriQueueThreadListHead)
.field("OffsetKThreadWaitReason", &self.OffsetKThreadWaitReason)
.field("Padding1", &self.Padding1)
.field("PteBase", &self.PteBase)
.field("RetpolineStubFunctionTable", &self.RetpolineStubFunctionTable)
.field("RetpolineStubFunctionTableSize", &self.RetpolineStubFunctionTableSize)
.field("RetpolineStubOffset", &self.RetpolineStubOffset)
.field("RetpolineStubSize", &self.RetpolineStubSize)
.field("OffsetEProcessMmHotPatchContext", &self.OffsetEProcessMmHotPatchContext)
.finish()
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::PartialEq for KDDEBUGGER_DATA64 {
fn eq(&self, other: &Self) -> bool {
self.Header == other.Header
&& self.KernBase == other.KernBase
&& self.BreakpointWithStatus == other.BreakpointWithStatus
&& self.SavedContext == other.SavedContext
&& self.ThCallbackStack == other.ThCallbackStack
&& self.NextCallback == other.NextCallback
&& self.FramePointer == other.FramePointer
&& self._bitfield == other._bitfield
&& self.KiCallUserMode == other.KiCallUserMode
&& self.KeUserCallbackDispatcher == other.KeUserCallbackDispatcher
&& self.PsLoadedModuleList == other.PsLoadedModuleList
&& self.PsActiveProcessHead == other.PsActiveProcessHead
&& self.PspCidTable == other.PspCidTable
&& self.ExpSystemResourcesList == other.ExpSystemResourcesList
&& self.ExpPagedPoolDescriptor == other.ExpPagedPoolDescriptor
&& self.ExpNumberOfPagedPools == other.ExpNumberOfPagedPools
&& self.KeTimeIncrement == other.KeTimeIncrement
&& self.KeBugCheckCallbackListHead == other.KeBugCheckCallbackListHead
&& self.KiBugcheckData == other.KiBugcheckData
&& self.IopErrorLogListHead == other.IopErrorLogListHead
&& self.ObpRootDirectoryObject == other.ObpRootDirectoryObject
&& self.ObpTypeObjectType == other.ObpTypeObjectType
&& self.MmSystemCacheStart == other.MmSystemCacheStart
&& self.MmSystemCacheEnd == other.MmSystemCacheEnd
&& self.MmSystemCacheWs == other.MmSystemCacheWs
&& self.MmPfnDatabase == other.MmPfnDatabase
&& self.MmSystemPtesStart == other.MmSystemPtesStart
&& self.MmSystemPtesEnd == other.MmSystemPtesEnd
&& self.MmSubsectionBase == other.MmSubsectionBase
&& self.MmNumberOfPagingFiles == other.MmNumberOfPagingFiles
&& self.MmLowestPhysicalPage == other.MmLowestPhysicalPage
&& self.MmHighestPhysicalPage == other.MmHighestPhysicalPage
&& self.MmNumberOfPhysicalPages == other.MmNumberOfPhysicalPages
&& self.MmMaximumNonPagedPoolInBytes == other.MmMaximumNonPagedPoolInBytes
&& self.MmNonPagedSystemStart == other.MmNonPagedSystemStart
&& self.MmNonPagedPoolStart == other.MmNonPagedPoolStart
&& self.MmNonPagedPoolEnd == other.MmNonPagedPoolEnd
&& self.MmPagedPoolStart == other.MmPagedPoolStart
&& self.MmPagedPoolEnd == other.MmPagedPoolEnd
&& self.MmPagedPoolInformation == other.MmPagedPoolInformation
&& self.MmPageSize == other.MmPageSize
&& self.MmSizeOfPagedPoolInBytes == other.MmSizeOfPagedPoolInBytes
&& self.MmTotalCommitLimit == other.MmTotalCommitLimit
&& self.MmTotalCommittedPages == other.MmTotalCommittedPages
&& self.MmSharedCommit == other.MmSharedCommit
&& self.MmDriverCommit == other.MmDriverCommit
&& self.MmProcessCommit == other.MmProcessCommit
&& self.MmPagedPoolCommit == other.MmPagedPoolCommit
&& self.MmExtendedCommit == other.MmExtendedCommit
&& self.MmZeroedPageListHead == other.MmZeroedPageListHead
&& self.MmFreePageListHead == other.MmFreePageListHead
&& self.MmStandbyPageListHead == other.MmStandbyPageListHead
&& self.MmModifiedPageListHead == other.MmModifiedPageListHead
&& self.MmModifiedNoWritePageListHead == other.MmModifiedNoWritePageListHead
&& self.MmAvailablePages == other.MmAvailablePages
&& self.MmResidentAvailablePages == other.MmResidentAvailablePages
&& self.PoolTrackTable == other.PoolTrackTable
&& self.NonPagedPoolDescriptor == other.NonPagedPoolDescriptor
&& self.MmHighestUserAddress == other.MmHighestUserAddress
&& self.MmSystemRangeStart == other.MmSystemRangeStart
&& self.MmUserProbeAddress == other.MmUserProbeAddress
&& self.KdPrintCircularBuffer == other.KdPrintCircularBuffer
&& self.KdPrintCircularBufferEnd == other.KdPrintCircularBufferEnd
&& self.KdPrintWritePointer == other.KdPrintWritePointer
&& self.KdPrintRolloverCount == other.KdPrintRolloverCount
&& self.MmLoadedUserImageList == other.MmLoadedUserImageList
&& self.NtBuildLab == other.NtBuildLab
&& self.KiNormalSystemCall == other.KiNormalSystemCall
&& self.KiProcessorBlock == other.KiProcessorBlock
&& self.MmUnloadedDrivers == other.MmUnloadedDrivers
&& self.MmLastUnloadedDriver == other.MmLastUnloadedDriver
&& self.MmTriageActionTaken == other.MmTriageActionTaken
&& self.MmSpecialPoolTag == other.MmSpecialPoolTag
&& self.KernelVerifier == other.KernelVerifier
&& self.MmVerifierData == other.MmVerifierData
&& self.MmAllocatedNonPagedPool == other.MmAllocatedNonPagedPool
&& self.MmPeakCommitment == other.MmPeakCommitment
&& self.MmTotalCommitLimitMaximum == other.MmTotalCommitLimitMaximum
&& self.CmNtCSDVersion == other.CmNtCSDVersion
&& self.MmPhysicalMemoryBlock == other.MmPhysicalMemoryBlock
&& self.MmSessionBase == other.MmSessionBase
&& self.MmSessionSize == other.MmSessionSize
&& self.MmSystemParentTablePage == other.MmSystemParentTablePage
&& self.MmVirtualTranslationBase == other.MmVirtualTranslationBase
&& self.OffsetKThreadNextProcessor == other.OffsetKThreadNextProcessor
&& self.OffsetKThreadTeb == other.OffsetKThreadTeb
&& self.OffsetKThreadKernelStack == other.OffsetKThreadKernelStack
&& self.OffsetKThreadInitialStack == other.OffsetKThreadInitialStack
&& self.OffsetKThreadApcProcess == other.OffsetKThreadApcProcess
&& self.OffsetKThreadState == other.OffsetKThreadState
&& self.OffsetKThreadBStore == other.OffsetKThreadBStore
&& self.OffsetKThreadBStoreLimit == other.OffsetKThreadBStoreLimit
&& self.SizeEProcess == other.SizeEProcess
&& self.OffsetEprocessPeb == other.OffsetEprocessPeb
&& self.OffsetEprocessParentCID == other.OffsetEprocessParentCID
&& self.OffsetEprocessDirectoryTableBase == other.OffsetEprocessDirectoryTableBase
&& self.SizePrcb == other.SizePrcb
&& self.OffsetPrcbDpcRoutine == other.OffsetPrcbDpcRoutine
&& self.OffsetPrcbCurrentThread == other.OffsetPrcbCurrentThread
&& self.OffsetPrcbMhz == other.OffsetPrcbMhz
&& self.OffsetPrcbCpuType == other.OffsetPrcbCpuType
&& self.OffsetPrcbVendorString == other.OffsetPrcbVendorString
&& self.OffsetPrcbProcStateContext == other.OffsetPrcbProcStateContext
&& self.OffsetPrcbNumber == other.OffsetPrcbNumber
&& self.SizeEThread == other.SizeEThread
&& self.L1tfHighPhysicalBitIndex == other.L1tfHighPhysicalBitIndex
&& self.L1tfSwizzleBitIndex == other.L1tfSwizzleBitIndex
&& self.Padding0 == other.Padding0
&& self.KdPrintCircularBufferPtr == other.KdPrintCircularBufferPtr
&& self.KdPrintBufferSize == other.KdPrintBufferSize
&& self.KeLoaderBlock == other.KeLoaderBlock
&& self.SizePcr == other.SizePcr
&& self.OffsetPcrSelfPcr == other.OffsetPcrSelfPcr
&& self.OffsetPcrCurrentPrcb == other.OffsetPcrCurrentPrcb
&& self.OffsetPcrContainedPrcb == other.OffsetPcrContainedPrcb
&& self.OffsetPcrInitialBStore == other.OffsetPcrInitialBStore
&& self.OffsetPcrBStoreLimit == other.OffsetPcrBStoreLimit
&& self.OffsetPcrInitialStack == other.OffsetPcrInitialStack
&& self.OffsetPcrStackLimit == other.OffsetPcrStackLimit
&& self.OffsetPrcbPcrPage == other.OffsetPrcbPcrPage
&& self.OffsetPrcbProcStateSpecialReg == other.OffsetPrcbProcStateSpecialReg
&& self.GdtR0Code == other.GdtR0Code
&& self.GdtR0Data == other.GdtR0Data
&& self.GdtR0Pcr == other.GdtR0Pcr
&& self.GdtR3Code == other.GdtR3Code
&& self.GdtR3Data == other.GdtR3Data
&& self.GdtR3Teb == other.GdtR3Teb
&& self.GdtLdt == other.GdtLdt
&& self.GdtTss == other.GdtTss
&& self.Gdt64R3CmCode == other.Gdt64R3CmCode
&& self.Gdt64R3CmTeb == other.Gdt64R3CmTeb
&& self.IopNumTriageDumpDataBlocks == other.IopNumTriageDumpDataBlocks
&& self.IopTriageDumpDataBlocks == other.IopTriageDumpDataBlocks
&& self.VfCrashDataBlock == other.VfCrashDataBlock
&& self.MmBadPagesDetected == other.MmBadPagesDetected
&& self.MmZeroedPageSingleBitErrorsDetected == other.MmZeroedPageSingleBitErrorsDetected
&& self.EtwpDebuggerData == other.EtwpDebuggerData
&& self.OffsetPrcbContext == other.OffsetPrcbContext
&& self.OffsetPrcbMaxBreakpoints == other.OffsetPrcbMaxBreakpoints
&& self.OffsetPrcbMaxWatchpoints == other.OffsetPrcbMaxWatchpoints
&& self.OffsetKThreadStackLimit == other.OffsetKThreadStackLimit
&& self.OffsetKThreadStackBase == other.OffsetKThreadStackBase
&& self.OffsetKThreadQueueListEntry == other.OffsetKThreadQueueListEntry
&& self.OffsetEThreadIrpList == other.OffsetEThreadIrpList
&& self.OffsetPrcbIdleThread == other.OffsetPrcbIdleThread
&& self.OffsetPrcbNormalDpcState == other.OffsetPrcbNormalDpcState
&& self.OffsetPrcbDpcStack == other.OffsetPrcbDpcStack
&& self.OffsetPrcbIsrStack == other.OffsetPrcbIsrStack
&& self.SizeKDPC_STACK_FRAME == other.SizeKDPC_STACK_FRAME
&& self.OffsetKPriQueueThreadListHead == other.OffsetKPriQueueThreadListHead
&& self.OffsetKThreadWaitReason == other.OffsetKThreadWaitReason
&& self.Padding1 == other.Padding1
&& self.PteBase == other.PteBase
&& self.RetpolineStubFunctionTable == other.RetpolineStubFunctionTable
&& self.RetpolineStubFunctionTableSize == other.RetpolineStubFunctionTableSize
&& self.RetpolineStubOffset == other.RetpolineStubOffset
&& self.RetpolineStubSize == other.RetpolineStubSize
&& self.OffsetEProcessMmHotPatchContext == other.OffsetEProcessMmHotPatchContext
}
}
#[cfg(feature = "Win32_System_Kernel")]
impl ::core::cmp::Eq for KDDEBUGGER_DATA64 {}
#[cfg(feature = "Win32_System_Kernel")]
unsafe impl ::windows::core::Abi for KDDEBUGGER_DATA64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct KDHELP {
pub Thread: u32,
pub ThCallbackStack: u32,
pub NextCallback: u32,
pub FramePointer: u32,
pub KiCallUserMode: u32,
pub KeUserCallbackDispatcher: u32,
pub SystemRangeStart: u32,
pub ThCallbackBStore: u32,
pub KiUserExceptionDispatcher: u32,
pub StackBase: u32,
pub StackLimit: u32,
pub Reserved: [u32; 5],
}
#[cfg(any(target_arch = "x86",))]
impl KDHELP {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for KDHELP {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for KDHELP {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KDHELP")
.field("Thread", &self.Thread)
.field("ThCallbackStack", &self.ThCallbackStack)
.field("NextCallback", &self.NextCallback)
.field("FramePointer", &self.FramePointer)
.field("KiCallUserMode", &self.KiCallUserMode)
.field("KeUserCallbackDispatcher", &self.KeUserCallbackDispatcher)
.field("SystemRangeStart", &self.SystemRangeStart)
.field("ThCallbackBStore", &self.ThCallbackBStore)
.field("KiUserExceptionDispatcher", &self.KiUserExceptionDispatcher)
.field("StackBase", &self.StackBase)
.field("StackLimit", &self.StackLimit)
.field("Reserved", &self.Reserved)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for KDHELP {
fn eq(&self, other: &Self) -> bool {
self.Thread == other.Thread
&& self.ThCallbackStack == other.ThCallbackStack
&& self.NextCallback == other.NextCallback
&& self.FramePointer == other.FramePointer
&& self.KiCallUserMode == other.KiCallUserMode
&& self.KeUserCallbackDispatcher == other.KeUserCallbackDispatcher
&& self.SystemRangeStart == other.SystemRangeStart
&& self.ThCallbackBStore == other.ThCallbackBStore
&& self.KiUserExceptionDispatcher == other.KiUserExceptionDispatcher
&& self.StackBase == other.StackBase
&& self.StackLimit == other.StackLimit
&& self.Reserved == other.Reserved
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for KDHELP {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for KDHELP {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct KDHELP64 {
pub Thread: u64,
pub ThCallbackStack: u32,
pub ThCallbackBStore: u32,
pub NextCallback: u32,
pub FramePointer: u32,
pub KiCallUserMode: u64,
pub KeUserCallbackDispatcher: u64,
pub SystemRangeStart: u64,
pub KiUserExceptionDispatcher: u64,
pub StackBase: u64,
pub StackLimit: u64,
pub BuildVersion: u32,
pub RetpolineStubFunctionTableSize: u32,
pub RetpolineStubFunctionTable: u64,
pub RetpolineStubOffset: u32,
pub RetpolineStubSize: u32,
pub Reserved0: [u64; 2],
}
impl KDHELP64 {}
impl ::core::default::Default for KDHELP64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for KDHELP64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KDHELP64")
.field("Thread", &self.Thread)
.field("ThCallbackStack", &self.ThCallbackStack)
.field("ThCallbackBStore", &self.ThCallbackBStore)
.field("NextCallback", &self.NextCallback)
.field("FramePointer", &self.FramePointer)
.field("KiCallUserMode", &self.KiCallUserMode)
.field("KeUserCallbackDispatcher", &self.KeUserCallbackDispatcher)
.field("SystemRangeStart", &self.SystemRangeStart)
.field("KiUserExceptionDispatcher", &self.KiUserExceptionDispatcher)
.field("StackBase", &self.StackBase)
.field("StackLimit", &self.StackLimit)
.field("BuildVersion", &self.BuildVersion)
.field("RetpolineStubFunctionTableSize", &self.RetpolineStubFunctionTableSize)
.field("RetpolineStubFunctionTable", &self.RetpolineStubFunctionTable)
.field("RetpolineStubOffset", &self.RetpolineStubOffset)
.field("RetpolineStubSize", &self.RetpolineStubSize)
.field("Reserved0", &self.Reserved0)
.finish()
}
}
impl ::core::cmp::PartialEq for KDHELP64 {
fn eq(&self, other: &Self) -> bool {
self.Thread == other.Thread
&& self.ThCallbackStack == other.ThCallbackStack
&& self.ThCallbackBStore == other.ThCallbackBStore
&& self.NextCallback == other.NextCallback
&& self.FramePointer == other.FramePointer
&& self.KiCallUserMode == other.KiCallUserMode
&& self.KeUserCallbackDispatcher == other.KeUserCallbackDispatcher
&& self.SystemRangeStart == other.SystemRangeStart
&& self.KiUserExceptionDispatcher == other.KiUserExceptionDispatcher
&& self.StackBase == other.StackBase
&& self.StackLimit == other.StackLimit
&& self.BuildVersion == other.BuildVersion
&& self.RetpolineStubFunctionTableSize == other.RetpolineStubFunctionTableSize
&& self.RetpolineStubFunctionTable == other.RetpolineStubFunctionTable
&& self.RetpolineStubOffset == other.RetpolineStubOffset
&& self.RetpolineStubSize == other.RetpolineStubSize
&& self.Reserved0 == other.Reserved0
}
}
impl ::core::cmp::Eq for KDHELP64 {}
unsafe impl ::windows::core::Abi for KDHELP64 {
type Abi = Self;
}
pub const KD_SECONDARY_VERSION_AMD64_CONTEXT: u32 = 2u32;
pub const KD_SECONDARY_VERSION_AMD64_OBSOLETE_CONTEXT_1: u32 = 0u32;
pub const KD_SECONDARY_VERSION_AMD64_OBSOLETE_CONTEXT_2: u32 = 1u32;
pub const KD_SECONDARY_VERSION_DEFAULT: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub struct KNONVOLATILE_CONTEXT_POINTERS {
pub Anonymous1: KNONVOLATILE_CONTEXT_POINTERS_0,
pub Anonymous2: KNONVOLATILE_CONTEXT_POINTERS_1,
}
#[cfg(any(target_arch = "x86_64",))]
impl KNONVOLATILE_CONTEXT_POINTERS {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub union KNONVOLATILE_CONTEXT_POINTERS_0 {
pub FloatingContext: [*mut M128A; 16],
pub Anonymous: KNONVOLATILE_CONTEXT_POINTERS_0_0,
}
#[cfg(any(target_arch = "x86_64",))]
impl KNONVOLATILE_CONTEXT_POINTERS_0 {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS_0 {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub struct KNONVOLATILE_CONTEXT_POINTERS_0_0 {
pub Xmm0: *mut M128A,
pub Xmm1: *mut M128A,
pub Xmm2: *mut M128A,
pub Xmm3: *mut M128A,
pub Xmm4: *mut M128A,
pub Xmm5: *mut M128A,
pub Xmm6: *mut M128A,
pub Xmm7: *mut M128A,
pub Xmm8: *mut M128A,
pub Xmm9: *mut M128A,
pub Xmm10: *mut M128A,
pub Xmm11: *mut M128A,
pub Xmm12: *mut M128A,
pub Xmm13: *mut M128A,
pub Xmm14: *mut M128A,
pub Xmm15: *mut M128A,
}
#[cfg(any(target_arch = "x86_64",))]
impl KNONVOLATILE_CONTEXT_POINTERS_0_0 {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::fmt::Debug for KNONVOLATILE_CONTEXT_POINTERS_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct")
.field("Xmm0", &self.Xmm0)
.field("Xmm1", &self.Xmm1)
.field("Xmm2", &self.Xmm2)
.field("Xmm3", &self.Xmm3)
.field("Xmm4", &self.Xmm4)
.field("Xmm5", &self.Xmm5)
.field("Xmm6", &self.Xmm6)
.field("Xmm7", &self.Xmm7)
.field("Xmm8", &self.Xmm8)
.field("Xmm9", &self.Xmm9)
.field("Xmm10", &self.Xmm10)
.field("Xmm11", &self.Xmm11)
.field("Xmm12", &self.Xmm12)
.field("Xmm13", &self.Xmm13)
.field("Xmm14", &self.Xmm14)
.field("Xmm15", &self.Xmm15)
.finish()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS_0_0 {
fn eq(&self, other: &Self) -> bool {
self.Xmm0 == other.Xmm0 && self.Xmm1 == other.Xmm1 && self.Xmm2 == other.Xmm2 && self.Xmm3 == other.Xmm3 && self.Xmm4 == other.Xmm4 && self.Xmm5 == other.Xmm5 && self.Xmm6 == other.Xmm6 && self.Xmm7 == other.Xmm7 && self.Xmm8 == other.Xmm8 && self.Xmm9 == other.Xmm9 && self.Xmm10 == other.Xmm10 && self.Xmm11 == other.Xmm11 && self.Xmm12 == other.Xmm12 && self.Xmm13 == other.Xmm13 && self.Xmm14 == other.Xmm14 && self.Xmm15 == other.Xmm15
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS_0_0 {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub union KNONVOLATILE_CONTEXT_POINTERS_1 {
pub IntegerContext: [*mut u64; 16],
pub Anonymous: KNONVOLATILE_CONTEXT_POINTERS_1_0,
}
#[cfg(any(target_arch = "x86_64",))]
impl KNONVOLATILE_CONTEXT_POINTERS_1 {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS_1 {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub struct KNONVOLATILE_CONTEXT_POINTERS_1_0 {
pub Rax: *mut u64,
pub Rcx: *mut u64,
pub Rdx: *mut u64,
pub Rbx: *mut u64,
pub Rsp: *mut u64,
pub Rbp: *mut u64,
pub Rsi: *mut u64,
pub Rdi: *mut u64,
pub R8: *mut u64,
pub R9: *mut u64,
pub R10: *mut u64,
pub R11: *mut u64,
pub R12: *mut u64,
pub R13: *mut u64,
pub R14: *mut u64,
pub R15: *mut u64,
}
#[cfg(any(target_arch = "x86_64",))]
impl KNONVOLATILE_CONTEXT_POINTERS_1_0 {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS_1_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::fmt::Debug for KNONVOLATILE_CONTEXT_POINTERS_1_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct")
.field("Rax", &self.Rax)
.field("Rcx", &self.Rcx)
.field("Rdx", &self.Rdx)
.field("Rbx", &self.Rbx)
.field("Rsp", &self.Rsp)
.field("Rbp", &self.Rbp)
.field("Rsi", &self.Rsi)
.field("Rdi", &self.Rdi)
.field("R8", &self.R8)
.field("R9", &self.R9)
.field("R10", &self.R10)
.field("R11", &self.R11)
.field("R12", &self.R12)
.field("R13", &self.R13)
.field("R14", &self.R14)
.field("R15", &self.R15)
.finish()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS_1_0 {
fn eq(&self, other: &Self) -> bool {
self.Rax == other.Rax && self.Rcx == other.Rcx && self.Rdx == other.Rdx && self.Rbx == other.Rbx && self.Rsp == other.Rsp && self.Rbp == other.Rbp && self.Rsi == other.Rsi && self.Rdi == other.Rdi && self.R8 == other.R8 && self.R9 == other.R9 && self.R10 == other.R10 && self.R11 == other.R11 && self.R12 == other.R12 && self.R13 == other.R13 && self.R14 == other.R14 && self.R15 == other.R15
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS_1_0 {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS_1_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct KNONVOLATILE_CONTEXT_POINTERS {
pub Dummy: u32,
}
#[cfg(any(target_arch = "x86",))]
impl KNONVOLATILE_CONTEXT_POINTERS {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for KNONVOLATILE_CONTEXT_POINTERS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KNONVOLATILE_CONTEXT_POINTERS").field("Dummy", &self.Dummy).finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS {
fn eq(&self, other: &Self) -> bool {
self.Dummy == other.Dummy
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
pub struct KNONVOLATILE_CONTEXT_POINTERS_ARM64 {
pub X19: *mut u64,
pub X20: *mut u64,
pub X21: *mut u64,
pub X22: *mut u64,
pub X23: *mut u64,
pub X24: *mut u64,
pub X25: *mut u64,
pub X26: *mut u64,
pub X27: *mut u64,
pub X28: *mut u64,
pub Fp: *mut u64,
pub Lr: *mut u64,
pub D8: *mut u64,
pub D9: *mut u64,
pub D10: *mut u64,
pub D11: *mut u64,
pub D12: *mut u64,
pub D13: *mut u64,
pub D14: *mut u64,
pub D15: *mut u64,
}
#[cfg(any(target_arch = "aarch64",))]
impl KNONVOLATILE_CONTEXT_POINTERS_ARM64 {}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::default::Default for KNONVOLATILE_CONTEXT_POINTERS_ARM64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::fmt::Debug for KNONVOLATILE_CONTEXT_POINTERS_ARM64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("KNONVOLATILE_CONTEXT_POINTERS_ARM64")
.field("X19", &self.X19)
.field("X20", &self.X20)
.field("X21", &self.X21)
.field("X22", &self.X22)
.field("X23", &self.X23)
.field("X24", &self.X24)
.field("X25", &self.X25)
.field("X26", &self.X26)
.field("X27", &self.X27)
.field("X28", &self.X28)
.field("Fp", &self.Fp)
.field("Lr", &self.Lr)
.field("D8", &self.D8)
.field("D9", &self.D9)
.field("D10", &self.D10)
.field("D11", &self.D11)
.field("D12", &self.D12)
.field("D13", &self.D13)
.field("D14", &self.D14)
.field("D15", &self.D15)
.finish()
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for KNONVOLATILE_CONTEXT_POINTERS_ARM64 {
fn eq(&self, other: &Self) -> bool {
self.X19 == other.X19 && self.X20 == other.X20 && self.X21 == other.X21 && self.X22 == other.X22 && self.X23 == other.X23 && self.X24 == other.X24 && self.X25 == other.X25 && self.X26 == other.X26 && self.X27 == other.X27 && self.X28 == other.X28 && self.Fp == other.Fp && self.Lr == other.Lr && self.D8 == other.D8 && self.D9 == other.D9 && self.D10 == other.D10 && self.D11 == other.D11 && self.D12 == other.D12 && self.D13 == other.D13 && self.D14 == other.D14 && self.D15 == other.D15
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::cmp::Eq for KNONVOLATILE_CONTEXT_POINTERS_ARM64 {}
#[cfg(any(target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for KNONVOLATILE_CONTEXT_POINTERS_ARM64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct LDT_ENTRY {
pub LimitLow: u16,
pub BaseLow: u16,
pub HighWord: LDT_ENTRY_0,
}
impl LDT_ENTRY {}
impl ::core::default::Default for LDT_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for LDT_ENTRY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for LDT_ENTRY {}
unsafe impl ::windows::core::Abi for LDT_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union LDT_ENTRY_0 {
pub Bytes: LDT_ENTRY_0_1,
pub Bits: LDT_ENTRY_0_0,
}
impl LDT_ENTRY_0 {}
impl ::core::default::Default for LDT_ENTRY_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for LDT_ENTRY_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for LDT_ENTRY_0 {}
unsafe impl ::windows::core::Abi for LDT_ENTRY_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct LDT_ENTRY_0_0 {
pub _bitfield: u32,
}
impl LDT_ENTRY_0_0 {}
impl ::core::default::Default for LDT_ENTRY_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for LDT_ENTRY_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Bits_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for LDT_ENTRY_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for LDT_ENTRY_0_0 {}
unsafe impl ::windows::core::Abi for LDT_ENTRY_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct LDT_ENTRY_0_1 {
pub BaseMid: u8,
pub Flags1: u8,
pub Flags2: u8,
pub BaseHi: u8,
}
impl LDT_ENTRY_0_1 {}
impl ::core::default::Default for LDT_ENTRY_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for LDT_ENTRY_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Bytes_e__Struct").field("BaseMid", &self.BaseMid).field("Flags1", &self.Flags1).field("Flags2", &self.Flags2).field("BaseHi", &self.BaseHi).finish()
}
}
impl ::core::cmp::PartialEq for LDT_ENTRY_0_1 {
fn eq(&self, other: &Self) -> bool {
self.BaseMid == other.BaseMid && self.Flags1 == other.Flags1 && self.Flags2 == other.Flags2 && self.BaseHi == other.BaseHi
}
}
impl ::core::cmp::Eq for LDT_ENTRY_0_1 {}
unsafe impl ::windows::core::Abi for LDT_ENTRY_0_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct LOADED_IMAGE {
pub ModuleName: super::super::super::Foundation::PSTR,
pub hFile: super::super::super::Foundation::HANDLE,
pub MappedAddress: *mut u8,
pub FileHeader: *mut IMAGE_NT_HEADERS64,
pub LastRvaSection: *mut IMAGE_SECTION_HEADER,
pub NumberOfSections: u32,
pub Sections: *mut IMAGE_SECTION_HEADER,
pub Characteristics: IMAGE_FILE_CHARACTERISTICS2,
pub fSystemImage: super::super::super::Foundation::BOOLEAN,
pub fDOSImage: super::super::super::Foundation::BOOLEAN,
pub fReadOnly: super::super::super::Foundation::BOOLEAN,
pub Version: u8,
pub Links: super::super::Kernel::LIST_ENTRY,
pub SizeOfImage: u32,
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl LOADED_IMAGE {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for LOADED_IMAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for LOADED_IMAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("LOADED_IMAGE")
.field("ModuleName", &self.ModuleName)
.field("hFile", &self.hFile)
.field("MappedAddress", &self.MappedAddress)
.field("FileHeader", &self.FileHeader)
.field("LastRvaSection", &self.LastRvaSection)
.field("NumberOfSections", &self.NumberOfSections)
.field("Sections", &self.Sections)
.field("Characteristics", &self.Characteristics)
.field("fSystemImage", &self.fSystemImage)
.field("fDOSImage", &self.fDOSImage)
.field("fReadOnly", &self.fReadOnly)
.field("Version", &self.Version)
.field("Links", &self.Links)
.field("SizeOfImage", &self.SizeOfImage)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for LOADED_IMAGE {
fn eq(&self, other: &Self) -> bool {
self.ModuleName == other.ModuleName
&& self.hFile == other.hFile
&& self.MappedAddress == other.MappedAddress
&& self.FileHeader == other.FileHeader
&& self.LastRvaSection == other.LastRvaSection
&& self.NumberOfSections == other.NumberOfSections
&& self.Sections == other.Sections
&& self.Characteristics == other.Characteristics
&& self.fSystemImage == other.fSystemImage
&& self.fDOSImage == other.fDOSImage
&& self.fReadOnly == other.fReadOnly
&& self.Version == other.Version
&& self.Links == other.Links
&& self.SizeOfImage == other.SizeOfImage
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for LOADED_IMAGE {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for LOADED_IMAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct LOADED_IMAGE {
pub ModuleName: super::super::super::Foundation::PSTR,
pub hFile: super::super::super::Foundation::HANDLE,
pub MappedAddress: *mut u8,
pub FileHeader: *mut IMAGE_NT_HEADERS32,
pub LastRvaSection: *mut IMAGE_SECTION_HEADER,
pub NumberOfSections: u32,
pub Sections: *mut IMAGE_SECTION_HEADER,
pub Characteristics: IMAGE_FILE_CHARACTERISTICS2,
pub fSystemImage: super::super::super::Foundation::BOOLEAN,
pub fDOSImage: super::super::super::Foundation::BOOLEAN,
pub fReadOnly: super::super::super::Foundation::BOOLEAN,
pub Version: u8,
pub Links: super::super::Kernel::LIST_ENTRY,
pub SizeOfImage: u32,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl LOADED_IMAGE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for LOADED_IMAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for LOADED_IMAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("LOADED_IMAGE")
.field("ModuleName", &self.ModuleName)
.field("hFile", &self.hFile)
.field("MappedAddress", &self.MappedAddress)
.field("FileHeader", &self.FileHeader)
.field("LastRvaSection", &self.LastRvaSection)
.field("NumberOfSections", &self.NumberOfSections)
.field("Sections", &self.Sections)
.field("Characteristics", &self.Characteristics)
.field("fSystemImage", &self.fSystemImage)
.field("fDOSImage", &self.fDOSImage)
.field("fReadOnly", &self.fReadOnly)
.field("Version", &self.Version)
.field("Links", &self.Links)
.field("SizeOfImage", &self.SizeOfImage)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for LOADED_IMAGE {
fn eq(&self, other: &Self) -> bool {
self.ModuleName == other.ModuleName
&& self.hFile == other.hFile
&& self.MappedAddress == other.MappedAddress
&& self.FileHeader == other.FileHeader
&& self.LastRvaSection == other.LastRvaSection
&& self.NumberOfSections == other.NumberOfSections
&& self.Sections == other.Sections
&& self.Characteristics == other.Characteristics
&& self.fSystemImage == other.fSystemImage
&& self.fDOSImage == other.fDOSImage
&& self.fReadOnly == other.fReadOnly
&& self.Version == other.Version
&& self.Links == other.Links
&& self.SizeOfImage == other.SizeOfImage
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for LOADED_IMAGE {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for LOADED_IMAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct LOAD_DLL_DEBUG_INFO {
pub hFile: super::super::super::Foundation::HANDLE,
pub lpBaseOfDll: *mut ::core::ffi::c_void,
pub dwDebugInfoFileOffset: u32,
pub nDebugInfoSize: u32,
pub lpImageName: *mut ::core::ffi::c_void,
pub fUnicode: u16,
}
#[cfg(feature = "Win32_Foundation")]
impl LOAD_DLL_DEBUG_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for LOAD_DLL_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for LOAD_DLL_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("LOAD_DLL_DEBUG_INFO").field("hFile", &self.hFile).field("lpBaseOfDll", &self.lpBaseOfDll).field("dwDebugInfoFileOffset", &self.dwDebugInfoFileOffset).field("nDebugInfoSize", &self.nDebugInfoSize).field("lpImageName", &self.lpImageName).field("fUnicode", &self.fUnicode).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for LOAD_DLL_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.hFile == other.hFile && self.lpBaseOfDll == other.lpBaseOfDll && self.dwDebugInfoFileOffset == other.dwDebugInfoFileOffset && self.nDebugInfoSize == other.nDebugInfoSize && self.lpImageName == other.lpImageName && self.fUnicode == other.fUnicode
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for LOAD_DLL_DEBUG_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for LOAD_DLL_DEBUG_INFO {
type Abi = Self;
}
pub type LPCALL_BACK_USER_INTERRUPT_ROUTINE = unsafe extern "system" fn() -> u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type LPTOP_LEVEL_EXCEPTION_FILTER = unsafe extern "system" fn(exceptioninfo: *const EXCEPTION_POINTERS) -> i32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct LanguageKind(pub i32);
pub const LanguageUnknown: LanguageKind = LanguageKind(0i32);
pub const LanguageC: LanguageKind = LanguageKind(1i32);
pub const LanguageCPP: LanguageKind = LanguageKind(2i32);
pub const LanguageAssembly: LanguageKind = LanguageKind(3i32);
impl ::core::convert::From<i32> for LanguageKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for LanguageKind {
type Abi = Self;
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
#[inline]
pub unsafe fn LocateXStateFeature(context: *const CONTEXT, featureid: u32, length: *mut u32) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn LocateXStateFeature(context: *const CONTEXT, featureid: u32, length: *mut u32) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(LocateXStateFeature(::core::mem::transmute(context), ::core::mem::transmute(featureid), ::core::mem::transmute(length)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct Location {
pub HostDefined: u64,
pub Offset: u64,
}
impl Location {}
impl ::core::default::Default for Location {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for Location {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("Location").field("HostDefined", &self.HostDefined).field("Offset", &self.Offset).finish()
}
}
impl ::core::cmp::PartialEq for Location {
fn eq(&self, other: &Self) -> bool {
self.HostDefined == other.HostDefined && self.Offset == other.Offset
}
}
impl ::core::cmp::Eq for Location {}
unsafe impl ::windows::core::Abi for Location {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct LocationKind(pub i32);
pub const LocationMember: LocationKind = LocationKind(0i32);
pub const LocationStatic: LocationKind = LocationKind(1i32);
pub const LocationConstant: LocationKind = LocationKind(2i32);
pub const LocationNone: LocationKind = LocationKind(3i32);
impl ::core::convert::From<i32> for LocationKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for LocationKind {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct M128A {
pub Low: u64,
pub High: i64,
}
impl M128A {}
impl ::core::default::Default for M128A {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for M128A {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("M128A").field("Low", &self.Low).field("High", &self.High).finish()
}
}
impl ::core::cmp::PartialEq for M128A {
fn eq(&self, other: &Self) -> bool {
self.Low == other.Low && self.High == other.High
}
}
impl ::core::cmp::Eq for M128A {}
unsafe impl ::windows::core::Abi for M128A {
type Abi = Self;
}
pub const MAX_SYM_NAME: u32 = 2000u32;
pub const MEMORY_READ_ERROR: u32 = 1u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
impl ::core::clone::Clone for MINIDUMP_CALLBACK_INFORMATION {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(4))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_INFORMATION {
pub CallbackRoutine: ::core::option::Option<MINIDUMP_CALLBACK_ROUTINE>,
pub CallbackParam: *mut ::core::ffi::c_void,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_INFORMATION {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_INFORMATION {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_INFORMATION {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_CALLBACK_INPUT {
pub ProcessId: u32,
pub ProcessHandle: super::super::super::Foundation::HANDLE,
pub CallbackType: u32,
pub Anonymous: MINIDUMP_CALLBACK_INPUT_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl MINIDUMP_CALLBACK_INPUT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_INPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_INPUT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_INPUT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_INPUT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
pub union MINIDUMP_CALLBACK_INPUT_0 {
pub Status: ::windows::core::HRESULT,
pub Thread: MINIDUMP_THREAD_CALLBACK,
pub ThreadEx: MINIDUMP_THREAD_EX_CALLBACK,
pub Module: MINIDUMP_MODULE_CALLBACK,
pub IncludeThread: MINIDUMP_INCLUDE_THREAD_CALLBACK,
pub IncludeModule: MINIDUMP_INCLUDE_MODULE_CALLBACK,
pub Io: MINIDUMP_IO_CALLBACK,
pub ReadMemoryFailure: MINIDUMP_READ_MEMORY_FAILURE_CALLBACK,
pub SecondaryFlags: u32,
pub VmQuery: MINIDUMP_VM_QUERY_CALLBACK,
pub VmPreRead: MINIDUMP_VM_PRE_READ_CALLBACK,
pub VmPostRead: MINIDUMP_VM_POST_READ_CALLBACK,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl MINIDUMP_CALLBACK_INPUT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_INPUT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_INPUT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_INPUT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_INPUT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT {
pub Anonymous: MINIDUMP_CALLBACK_OUTPUT_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub union MINIDUMP_CALLBACK_OUTPUT_0 {
pub ModuleWriteFlags: u32,
pub ThreadWriteFlags: u32,
pub SecondaryFlags: u32,
pub Anonymous1: MINIDUMP_CALLBACK_OUTPUT_0_0,
pub Anonymous2: MINIDUMP_CALLBACK_OUTPUT_0_1,
pub Handle: super::super::super::Foundation::HANDLE,
pub Anonymous3: MINIDUMP_CALLBACK_OUTPUT_0_2,
pub Anonymous4: MINIDUMP_CALLBACK_OUTPUT_0_3,
pub Anonymous5: MINIDUMP_CALLBACK_OUTPUT_0_4,
pub Status: ::windows::core::HRESULT,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT_0_0 {
pub MemoryBase: u64,
pub MemorySize: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT_0_1 {
pub CheckCancel: super::super::super::Foundation::BOOL,
pub Cancel: super::super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0_1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::fmt::Debug for MINIDUMP_CALLBACK_OUTPUT_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous2_e__Struct").field("CheckCancel", &self.CheckCancel).field("Cancel", &self.Cancel).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0_1 {
fn eq(&self, other: &Self) -> bool {
self.CheckCancel == other.CheckCancel && self.Cancel == other.Cancel
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0_1 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT_0_2 {
pub VmRegion: MINIDUMP_MEMORY_INFO,
pub Continue: super::super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0_2 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0_2 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0_2 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0_2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT_0_3 {
pub VmQueryStatus: ::windows::core::HRESULT,
pub VmQueryResult: MINIDUMP_MEMORY_INFO,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0_3 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0_3 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0_3 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0_3 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0_3 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
pub struct MINIDUMP_CALLBACK_OUTPUT_0_4 {
pub VmReadStatus: ::windows::core::HRESULT,
pub VmReadBytesCompleted: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl MINIDUMP_CALLBACK_OUTPUT_0_4 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::default::Default for MINIDUMP_CALLBACK_OUTPUT_0_4 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::fmt::Debug for MINIDUMP_CALLBACK_OUTPUT_0_4 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous5_e__Struct").field("VmReadStatus", &self.VmReadStatus).field("VmReadBytesCompleted", &self.VmReadBytesCompleted).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::PartialEq for MINIDUMP_CALLBACK_OUTPUT_0_4 {
fn eq(&self, other: &Self) -> bool {
self.VmReadStatus == other.VmReadStatus && self.VmReadBytesCompleted == other.VmReadBytesCompleted
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
impl ::core::cmp::Eq for MINIDUMP_CALLBACK_OUTPUT_0_4 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Memory"))]
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_OUTPUT_0_4 {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
pub type MINIDUMP_CALLBACK_ROUTINE = unsafe extern "system" fn(callbackparam: *mut ::core::ffi::c_void, callbackinput: *const MINIDUMP_CALLBACK_INPUT, callbackoutput: *mut MINIDUMP_CALLBACK_OUTPUT) -> super::super::super::Foundation::BOOL;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_CALLBACK_TYPE(pub i32);
pub const ModuleCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(0i32);
pub const ThreadCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(1i32);
pub const ThreadExCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(2i32);
pub const IncludeThreadCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(3i32);
pub const IncludeModuleCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(4i32);
pub const MemoryCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(5i32);
pub const CancelCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(6i32);
pub const WriteKernelMinidumpCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(7i32);
pub const KernelMinidumpStatusCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(8i32);
pub const RemoveMemoryCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(9i32);
pub const IncludeVmRegionCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(10i32);
pub const IoStartCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(11i32);
pub const IoWriteAllCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(12i32);
pub const IoFinishCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(13i32);
pub const ReadMemoryFailureCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(14i32);
pub const SecondaryFlagsCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(15i32);
pub const IsProcessSnapshotCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(16i32);
pub const VmStartCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(17i32);
pub const VmQueryCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(18i32);
pub const VmPreReadCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(19i32);
pub const VmPostReadCallback: MINIDUMP_CALLBACK_TYPE = MINIDUMP_CALLBACK_TYPE(20i32);
impl ::core::convert::From<i32> for MINIDUMP_CALLBACK_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_CALLBACK_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_DIRECTORY {
pub StreamType: u32,
pub Location: MINIDUMP_LOCATION_DESCRIPTOR,
}
impl MINIDUMP_DIRECTORY {}
impl ::core::default::Default for MINIDUMP_DIRECTORY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_DIRECTORY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_DIRECTORY").field("StreamType", &self.StreamType).field("Location", &self.Location).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_DIRECTORY {
fn eq(&self, other: &Self) -> bool {
self.StreamType == other.StreamType && self.Location == other.Location
}
}
impl ::core::cmp::Eq for MINIDUMP_DIRECTORY {}
unsafe impl ::windows::core::Abi for MINIDUMP_DIRECTORY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_EXCEPTION {
pub ExceptionCode: u32,
pub ExceptionFlags: u32,
pub ExceptionRecord: u64,
pub ExceptionAddress: u64,
pub NumberParameters: u32,
pub __unusedAlignment: u32,
pub ExceptionInformation: [u64; 15],
}
impl MINIDUMP_EXCEPTION {}
impl ::core::default::Default for MINIDUMP_EXCEPTION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_EXCEPTION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_EXCEPTION {}
unsafe impl ::windows::core::Abi for MINIDUMP_EXCEPTION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_EXCEPTION_INFORMATION {
pub ThreadId: u32,
pub ExceptionPointers: *mut EXCEPTION_POINTERS,
pub ClientPointers: super::super::super::Foundation::BOOL,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_EXCEPTION_INFORMATION {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_EXCEPTION_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_EXCEPTION_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_EXCEPTION_INFORMATION {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_EXCEPTION_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(feature = "Win32_Foundation")]
pub struct MINIDUMP_EXCEPTION_INFORMATION64 {
pub ThreadId: u32,
pub ExceptionRecord: u64,
pub ContextRecord: u64,
pub ClientPointers: super::super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl MINIDUMP_EXCEPTION_INFORMATION64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MINIDUMP_EXCEPTION_INFORMATION64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MINIDUMP_EXCEPTION_INFORMATION64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MINIDUMP_EXCEPTION_INFORMATION64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MINIDUMP_EXCEPTION_INFORMATION64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_EXCEPTION_STREAM {
pub ThreadId: u32,
pub __alignment: u32,
pub ExceptionRecord: MINIDUMP_EXCEPTION,
pub ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR,
}
impl MINIDUMP_EXCEPTION_STREAM {}
impl ::core::default::Default for MINIDUMP_EXCEPTION_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_EXCEPTION_STREAM {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_EXCEPTION_STREAM {}
unsafe impl ::windows::core::Abi for MINIDUMP_EXCEPTION_STREAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
pub MinimumAddress: u64,
pub MaximumAddress: u64,
pub BaseAddress: u64,
pub EntryCount: u32,
pub SizeOfAlignPad: u32,
}
impl MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {}
impl ::core::default::Default for MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for MINIDUMP_FUNCTION_TABLE_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_FUNCTION_TABLE_STREAM {
pub SizeOfHeader: u32,
pub SizeOfDescriptor: u32,
pub SizeOfNativeDescriptor: u32,
pub SizeOfFunctionEntry: u32,
pub NumberOfDescriptors: u32,
pub SizeOfAlignPad: u32,
}
impl MINIDUMP_FUNCTION_TABLE_STREAM {}
impl ::core::default::Default for MINIDUMP_FUNCTION_TABLE_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_FUNCTION_TABLE_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_FUNCTION_TABLE_STREAM")
.field("SizeOfHeader", &self.SizeOfHeader)
.field("SizeOfDescriptor", &self.SizeOfDescriptor)
.field("SizeOfNativeDescriptor", &self.SizeOfNativeDescriptor)
.field("SizeOfFunctionEntry", &self.SizeOfFunctionEntry)
.field("NumberOfDescriptors", &self.NumberOfDescriptors)
.field("SizeOfAlignPad", &self.SizeOfAlignPad)
.finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_FUNCTION_TABLE_STREAM {
fn eq(&self, other: &Self) -> bool {
self.SizeOfHeader == other.SizeOfHeader && self.SizeOfDescriptor == other.SizeOfDescriptor && self.SizeOfNativeDescriptor == other.SizeOfNativeDescriptor && self.SizeOfFunctionEntry == other.SizeOfFunctionEntry && self.NumberOfDescriptors == other.NumberOfDescriptors && self.SizeOfAlignPad == other.SizeOfAlignPad
}
}
impl ::core::cmp::Eq for MINIDUMP_FUNCTION_TABLE_STREAM {}
unsafe impl ::windows::core::Abi for MINIDUMP_FUNCTION_TABLE_STREAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_HANDLE_DATA_STREAM {
pub SizeOfHeader: u32,
pub SizeOfDescriptor: u32,
pub NumberOfDescriptors: u32,
pub Reserved: u32,
}
impl MINIDUMP_HANDLE_DATA_STREAM {}
impl ::core::default::Default for MINIDUMP_HANDLE_DATA_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_HANDLE_DATA_STREAM {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_HANDLE_DATA_STREAM").field("SizeOfHeader", &self.SizeOfHeader).field("SizeOfDescriptor", &self.SizeOfDescriptor).field("NumberOfDescriptors", &self.NumberOfDescriptors).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HANDLE_DATA_STREAM {
fn eq(&self, other: &Self) -> bool {
self.SizeOfHeader == other.SizeOfHeader && self.SizeOfDescriptor == other.SizeOfDescriptor && self.NumberOfDescriptors == other.NumberOfDescriptors && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for MINIDUMP_HANDLE_DATA_STREAM {}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_DATA_STREAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_HANDLE_DESCRIPTOR {
pub Handle: u64,
pub TypeNameRva: u32,
pub ObjectNameRva: u32,
pub Attributes: u32,
pub GrantedAccess: u32,
pub HandleCount: u32,
pub PointerCount: u32,
}
impl MINIDUMP_HANDLE_DESCRIPTOR {}
impl ::core::default::Default for MINIDUMP_HANDLE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HANDLE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_HANDLE_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_HANDLE_DESCRIPTOR_2 {
pub Handle: u64,
pub TypeNameRva: u32,
pub ObjectNameRva: u32,
pub Attributes: u32,
pub GrantedAccess: u32,
pub HandleCount: u32,
pub PointerCount: u32,
pub ObjectInfoRva: u32,
pub Reserved0: u32,
}
impl MINIDUMP_HANDLE_DESCRIPTOR_2 {}
impl ::core::default::Default for MINIDUMP_HANDLE_DESCRIPTOR_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HANDLE_DESCRIPTOR_2 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_HANDLE_DESCRIPTOR_2 {}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_DESCRIPTOR_2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_HANDLE_OBJECT_INFORMATION {
pub NextInfoRva: u32,
pub InfoType: u32,
pub SizeOfInfo: u32,
}
impl MINIDUMP_HANDLE_OBJECT_INFORMATION {}
impl ::core::default::Default for MINIDUMP_HANDLE_OBJECT_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_HANDLE_OBJECT_INFORMATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_HANDLE_OBJECT_INFORMATION").field("NextInfoRva", &self.NextInfoRva).field("InfoType", &self.InfoType).field("SizeOfInfo", &self.SizeOfInfo).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HANDLE_OBJECT_INFORMATION {
fn eq(&self, other: &Self) -> bool {
self.NextInfoRva == other.NextInfoRva && self.InfoType == other.InfoType && self.SizeOfInfo == other.SizeOfInfo
}
}
impl ::core::cmp::Eq for MINIDUMP_HANDLE_OBJECT_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_OBJECT_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(pub i32);
pub const MiniHandleObjectInformationNone: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(0i32);
pub const MiniThreadInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(1i32);
pub const MiniMutantInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(2i32);
pub const MiniMutantInformation2: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(3i32);
pub const MiniProcessInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(4i32);
pub const MiniProcessInformation2: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(5i32);
pub const MiniEventInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(6i32);
pub const MiniSectionInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(7i32);
pub const MiniSemaphoreInformation1: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(8i32);
pub const MiniHandleObjectInformationTypeMax: MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE = MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE(9i32);
impl ::core::convert::From<i32> for MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_OBJECT_INFORMATION_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_HANDLE_OPERATION_LIST {
pub SizeOfHeader: u32,
pub SizeOfEntry: u32,
pub NumberOfEntries: u32,
pub Reserved: u32,
}
impl MINIDUMP_HANDLE_OPERATION_LIST {}
impl ::core::default::Default for MINIDUMP_HANDLE_OPERATION_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_HANDLE_OPERATION_LIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_HANDLE_OPERATION_LIST").field("SizeOfHeader", &self.SizeOfHeader).field("SizeOfEntry", &self.SizeOfEntry).field("NumberOfEntries", &self.NumberOfEntries).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HANDLE_OPERATION_LIST {
fn eq(&self, other: &Self) -> bool {
self.SizeOfHeader == other.SizeOfHeader && self.SizeOfEntry == other.SizeOfEntry && self.NumberOfEntries == other.NumberOfEntries && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for MINIDUMP_HANDLE_OPERATION_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_HANDLE_OPERATION_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_HEADER {
pub Signature: u32,
pub Version: u32,
pub NumberOfStreams: u32,
pub StreamDirectoryRva: u32,
pub CheckSum: u32,
pub Anonymous: MINIDUMP_HEADER_0,
pub Flags: u64,
}
impl MINIDUMP_HEADER {}
impl ::core::default::Default for MINIDUMP_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HEADER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_HEADER {}
unsafe impl ::windows::core::Abi for MINIDUMP_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union MINIDUMP_HEADER_0 {
pub Reserved: u32,
pub TimeDateStamp: u32,
}
impl MINIDUMP_HEADER_0 {}
impl ::core::default::Default for MINIDUMP_HEADER_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_HEADER_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_HEADER_0 {}
unsafe impl ::windows::core::Abi for MINIDUMP_HEADER_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_INCLUDE_MODULE_CALLBACK {
pub BaseOfImage: u64,
}
impl MINIDUMP_INCLUDE_MODULE_CALLBACK {}
impl ::core::default::Default for MINIDUMP_INCLUDE_MODULE_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_INCLUDE_MODULE_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_INCLUDE_MODULE_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_INCLUDE_MODULE_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_INCLUDE_THREAD_CALLBACK {
pub ThreadId: u32,
}
impl MINIDUMP_INCLUDE_THREAD_CALLBACK {}
impl ::core::default::Default for MINIDUMP_INCLUDE_THREAD_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_INCLUDE_THREAD_CALLBACK {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_INCLUDE_THREAD_CALLBACK").field("ThreadId", &self.ThreadId).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_INCLUDE_THREAD_CALLBACK {
fn eq(&self, other: &Self) -> bool {
self.ThreadId == other.ThreadId
}
}
impl ::core::cmp::Eq for MINIDUMP_INCLUDE_THREAD_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_INCLUDE_THREAD_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(feature = "Win32_Foundation")]
pub struct MINIDUMP_IO_CALLBACK {
pub Handle: super::super::super::Foundation::HANDLE,
pub Offset: u64,
pub Buffer: *mut ::core::ffi::c_void,
pub BufferBytes: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl MINIDUMP_IO_CALLBACK {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for MINIDUMP_IO_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for MINIDUMP_IO_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for MINIDUMP_IO_CALLBACK {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for MINIDUMP_IO_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_LOCATION_DESCRIPTOR {
pub DataSize: u32,
pub Rva: u32,
}
impl MINIDUMP_LOCATION_DESCRIPTOR {}
impl ::core::default::Default for MINIDUMP_LOCATION_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_LOCATION_DESCRIPTOR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_LOCATION_DESCRIPTOR").field("DataSize", &self.DataSize).field("Rva", &self.Rva).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_LOCATION_DESCRIPTOR {
fn eq(&self, other: &Self) -> bool {
self.DataSize == other.DataSize && self.Rva == other.Rva
}
}
impl ::core::cmp::Eq for MINIDUMP_LOCATION_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for MINIDUMP_LOCATION_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_LOCATION_DESCRIPTOR64 {
pub DataSize: u64,
pub Rva: u64,
}
impl MINIDUMP_LOCATION_DESCRIPTOR64 {}
impl ::core::default::Default for MINIDUMP_LOCATION_DESCRIPTOR64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_LOCATION_DESCRIPTOR64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_LOCATION_DESCRIPTOR64 {}
unsafe impl ::windows::core::Abi for MINIDUMP_LOCATION_DESCRIPTOR64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_MEMORY64_LIST {
pub NumberOfMemoryRanges: u64,
pub BaseRva: u64,
pub MemoryRanges: [MINIDUMP_MEMORY_DESCRIPTOR64; 1],
}
impl MINIDUMP_MEMORY64_LIST {}
impl ::core::default::Default for MINIDUMP_MEMORY64_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY64_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_MEMORY64_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY64_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_MEMORY_DESCRIPTOR {
pub StartOfMemoryRange: u64,
pub Memory: MINIDUMP_LOCATION_DESCRIPTOR,
}
impl MINIDUMP_MEMORY_DESCRIPTOR {}
impl ::core::default::Default for MINIDUMP_MEMORY_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_MEMORY_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_MEMORY_DESCRIPTOR64 {
pub StartOfMemoryRange: u64,
pub DataSize: u64,
}
impl MINIDUMP_MEMORY_DESCRIPTOR64 {}
impl ::core::default::Default for MINIDUMP_MEMORY_DESCRIPTOR64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY_DESCRIPTOR64 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_MEMORY_DESCRIPTOR64 {}
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY_DESCRIPTOR64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(feature = "Win32_System_Memory")]
pub struct MINIDUMP_MEMORY_INFO {
pub BaseAddress: u64,
pub AllocationBase: u64,
pub AllocationProtect: u32,
pub __alignment1: u32,
pub RegionSize: u64,
pub State: super::super::Memory::VIRTUAL_ALLOCATION_TYPE,
pub Protect: u32,
pub Type: u32,
pub __alignment2: u32,
}
#[cfg(feature = "Win32_System_Memory")]
impl MINIDUMP_MEMORY_INFO {}
#[cfg(feature = "Win32_System_Memory")]
impl ::core::default::Default for MINIDUMP_MEMORY_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_System_Memory")]
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_System_Memory")]
impl ::core::cmp::Eq for MINIDUMP_MEMORY_INFO {}
#[cfg(feature = "Win32_System_Memory")]
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_MEMORY_INFO_LIST {
pub SizeOfHeader: u32,
pub SizeOfEntry: u32,
pub NumberOfEntries: u64,
}
impl MINIDUMP_MEMORY_INFO_LIST {}
impl ::core::default::Default for MINIDUMP_MEMORY_INFO_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY_INFO_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_MEMORY_INFO_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY_INFO_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_MEMORY_LIST {
pub NumberOfMemoryRanges: u32,
pub MemoryRanges: [MINIDUMP_MEMORY_DESCRIPTOR; 1],
}
impl MINIDUMP_MEMORY_LIST {}
impl ::core::default::Default for MINIDUMP_MEMORY_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MEMORY_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_MEMORY_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_MEMORY_LIST {
type Abi = Self;
}
pub const MINIDUMP_MISC1_PROCESSOR_POWER_INFO: u32 = 4u32;
pub const MINIDUMP_MISC3_PROCESS_EXECUTE_FLAGS: u32 = 32u32;
pub const MINIDUMP_MISC3_PROCESS_INTEGRITY: u32 = 16u32;
pub const MINIDUMP_MISC3_PROTECTED_PROCESS: u32 = 128u32;
pub const MINIDUMP_MISC3_TIMEZONE: u32 = 64u32;
pub const MINIDUMP_MISC4_BUILDSTRING: u32 = 256u32;
pub const MINIDUMP_MISC5_PROCESS_COOKIE: u32 = 512u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_MISC_INFO {
pub SizeOfInfo: u32,
pub Flags1: MINIDUMP_MISC_INFO_FLAGS,
pub ProcessId: u32,
pub ProcessCreateTime: u32,
pub ProcessUserTime: u32,
pub ProcessKernelTime: u32,
}
impl MINIDUMP_MISC_INFO {}
impl ::core::default::Default for MINIDUMP_MISC_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_MISC_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_MISC_INFO")
.field("SizeOfInfo", &self.SizeOfInfo)
.field("Flags1", &self.Flags1)
.field("ProcessId", &self.ProcessId)
.field("ProcessCreateTime", &self.ProcessCreateTime)
.field("ProcessUserTime", &self.ProcessUserTime)
.field("ProcessKernelTime", &self.ProcessKernelTime)
.finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MISC_INFO {
fn eq(&self, other: &Self) -> bool {
self.SizeOfInfo == other.SizeOfInfo && self.Flags1 == other.Flags1 && self.ProcessId == other.ProcessId && self.ProcessCreateTime == other.ProcessCreateTime && self.ProcessUserTime == other.ProcessUserTime && self.ProcessKernelTime == other.ProcessKernelTime
}
}
impl ::core::cmp::Eq for MINIDUMP_MISC_INFO {}
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_MISC_INFO_2 {
pub SizeOfInfo: u32,
pub Flags1: u32,
pub ProcessId: u32,
pub ProcessCreateTime: u32,
pub ProcessUserTime: u32,
pub ProcessKernelTime: u32,
pub ProcessorMaxMhz: u32,
pub ProcessorCurrentMhz: u32,
pub ProcessorMhzLimit: u32,
pub ProcessorMaxIdleState: u32,
pub ProcessorCurrentIdleState: u32,
}
impl MINIDUMP_MISC_INFO_2 {}
impl ::core::default::Default for MINIDUMP_MISC_INFO_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_MISC_INFO_2 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_MISC_INFO_2")
.field("SizeOfInfo", &self.SizeOfInfo)
.field("Flags1", &self.Flags1)
.field("ProcessId", &self.ProcessId)
.field("ProcessCreateTime", &self.ProcessCreateTime)
.field("ProcessUserTime", &self.ProcessUserTime)
.field("ProcessKernelTime", &self.ProcessKernelTime)
.field("ProcessorMaxMhz", &self.ProcessorMaxMhz)
.field("ProcessorCurrentMhz", &self.ProcessorCurrentMhz)
.field("ProcessorMhzLimit", &self.ProcessorMhzLimit)
.field("ProcessorMaxIdleState", &self.ProcessorMaxIdleState)
.field("ProcessorCurrentIdleState", &self.ProcessorCurrentIdleState)
.finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_MISC_INFO_2 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfInfo == other.SizeOfInfo
&& self.Flags1 == other.Flags1
&& self.ProcessId == other.ProcessId
&& self.ProcessCreateTime == other.ProcessCreateTime
&& self.ProcessUserTime == other.ProcessUserTime
&& self.ProcessKernelTime == other.ProcessKernelTime
&& self.ProcessorMaxMhz == other.ProcessorMaxMhz
&& self.ProcessorCurrentMhz == other.ProcessorCurrentMhz
&& self.ProcessorMhzLimit == other.ProcessorMhzLimit
&& self.ProcessorMaxIdleState == other.ProcessorMaxIdleState
&& self.ProcessorCurrentIdleState == other.ProcessorCurrentIdleState
}
}
impl ::core::cmp::Eq for MINIDUMP_MISC_INFO_2 {}
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO_2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
pub struct MINIDUMP_MISC_INFO_3 {
pub SizeOfInfo: u32,
pub Flags1: u32,
pub ProcessId: u32,
pub ProcessCreateTime: u32,
pub ProcessUserTime: u32,
pub ProcessKernelTime: u32,
pub ProcessorMaxMhz: u32,
pub ProcessorCurrentMhz: u32,
pub ProcessorMhzLimit: u32,
pub ProcessorMaxIdleState: u32,
pub ProcessorCurrentIdleState: u32,
pub ProcessIntegrityLevel: u32,
pub ProcessExecuteFlags: u32,
pub ProtectedProcess: u32,
pub TimeZoneId: u32,
pub TimeZone: super::super::Time::TIME_ZONE_INFORMATION,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl MINIDUMP_MISC_INFO_3 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::default::Default for MINIDUMP_MISC_INFO_3 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::fmt::Debug for MINIDUMP_MISC_INFO_3 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_MISC_INFO_3")
.field("SizeOfInfo", &self.SizeOfInfo)
.field("Flags1", &self.Flags1)
.field("ProcessId", &self.ProcessId)
.field("ProcessCreateTime", &self.ProcessCreateTime)
.field("ProcessUserTime", &self.ProcessUserTime)
.field("ProcessKernelTime", &self.ProcessKernelTime)
.field("ProcessorMaxMhz", &self.ProcessorMaxMhz)
.field("ProcessorCurrentMhz", &self.ProcessorCurrentMhz)
.field("ProcessorMhzLimit", &self.ProcessorMhzLimit)
.field("ProcessorMaxIdleState", &self.ProcessorMaxIdleState)
.field("ProcessorCurrentIdleState", &self.ProcessorCurrentIdleState)
.field("ProcessIntegrityLevel", &self.ProcessIntegrityLevel)
.field("ProcessExecuteFlags", &self.ProcessExecuteFlags)
.field("ProtectedProcess", &self.ProtectedProcess)
.field("TimeZoneId", &self.TimeZoneId)
.field("TimeZone", &self.TimeZone)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::PartialEq for MINIDUMP_MISC_INFO_3 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfInfo == other.SizeOfInfo
&& self.Flags1 == other.Flags1
&& self.ProcessId == other.ProcessId
&& self.ProcessCreateTime == other.ProcessCreateTime
&& self.ProcessUserTime == other.ProcessUserTime
&& self.ProcessKernelTime == other.ProcessKernelTime
&& self.ProcessorMaxMhz == other.ProcessorMaxMhz
&& self.ProcessorCurrentMhz == other.ProcessorCurrentMhz
&& self.ProcessorMhzLimit == other.ProcessorMhzLimit
&& self.ProcessorMaxIdleState == other.ProcessorMaxIdleState
&& self.ProcessorCurrentIdleState == other.ProcessorCurrentIdleState
&& self.ProcessIntegrityLevel == other.ProcessIntegrityLevel
&& self.ProcessExecuteFlags == other.ProcessExecuteFlags
&& self.ProtectedProcess == other.ProtectedProcess
&& self.TimeZoneId == other.TimeZoneId
&& self.TimeZone == other.TimeZone
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::Eq for MINIDUMP_MISC_INFO_3 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO_3 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
pub struct MINIDUMP_MISC_INFO_4 {
pub SizeOfInfo: u32,
pub Flags1: u32,
pub ProcessId: u32,
pub ProcessCreateTime: u32,
pub ProcessUserTime: u32,
pub ProcessKernelTime: u32,
pub ProcessorMaxMhz: u32,
pub ProcessorCurrentMhz: u32,
pub ProcessorMhzLimit: u32,
pub ProcessorMaxIdleState: u32,
pub ProcessorCurrentIdleState: u32,
pub ProcessIntegrityLevel: u32,
pub ProcessExecuteFlags: u32,
pub ProtectedProcess: u32,
pub TimeZoneId: u32,
pub TimeZone: super::super::Time::TIME_ZONE_INFORMATION,
pub BuildString: [u16; 260],
pub DbgBldStr: [u16; 40],
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl MINIDUMP_MISC_INFO_4 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::default::Default for MINIDUMP_MISC_INFO_4 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::fmt::Debug for MINIDUMP_MISC_INFO_4 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_MISC_INFO_4")
.field("SizeOfInfo", &self.SizeOfInfo)
.field("Flags1", &self.Flags1)
.field("ProcessId", &self.ProcessId)
.field("ProcessCreateTime", &self.ProcessCreateTime)
.field("ProcessUserTime", &self.ProcessUserTime)
.field("ProcessKernelTime", &self.ProcessKernelTime)
.field("ProcessorMaxMhz", &self.ProcessorMaxMhz)
.field("ProcessorCurrentMhz", &self.ProcessorCurrentMhz)
.field("ProcessorMhzLimit", &self.ProcessorMhzLimit)
.field("ProcessorMaxIdleState", &self.ProcessorMaxIdleState)
.field("ProcessorCurrentIdleState", &self.ProcessorCurrentIdleState)
.field("ProcessIntegrityLevel", &self.ProcessIntegrityLevel)
.field("ProcessExecuteFlags", &self.ProcessExecuteFlags)
.field("ProtectedProcess", &self.ProtectedProcess)
.field("TimeZoneId", &self.TimeZoneId)
.field("TimeZone", &self.TimeZone)
.field("BuildString", &self.BuildString)
.field("DbgBldStr", &self.DbgBldStr)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::PartialEq for MINIDUMP_MISC_INFO_4 {
fn eq(&self, other: &Self) -> bool {
self.SizeOfInfo == other.SizeOfInfo
&& self.Flags1 == other.Flags1
&& self.ProcessId == other.ProcessId
&& self.ProcessCreateTime == other.ProcessCreateTime
&& self.ProcessUserTime == other.ProcessUserTime
&& self.ProcessKernelTime == other.ProcessKernelTime
&& self.ProcessorMaxMhz == other.ProcessorMaxMhz
&& self.ProcessorCurrentMhz == other.ProcessorCurrentMhz
&& self.ProcessorMhzLimit == other.ProcessorMhzLimit
&& self.ProcessorMaxIdleState == other.ProcessorMaxIdleState
&& self.ProcessorCurrentIdleState == other.ProcessorCurrentIdleState
&& self.ProcessIntegrityLevel == other.ProcessIntegrityLevel
&& self.ProcessExecuteFlags == other.ProcessExecuteFlags
&& self.ProtectedProcess == other.ProtectedProcess
&& self.TimeZoneId == other.TimeZoneId
&& self.TimeZone == other.TimeZone
&& self.BuildString == other.BuildString
&& self.DbgBldStr == other.DbgBldStr
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::Eq for MINIDUMP_MISC_INFO_4 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO_4 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
pub struct MINIDUMP_MISC_INFO_5 {
pub SizeOfInfo: u32,
pub Flags1: u32,
pub ProcessId: u32,
pub ProcessCreateTime: u32,
pub ProcessUserTime: u32,
pub ProcessKernelTime: u32,
pub ProcessorMaxMhz: u32,
pub ProcessorCurrentMhz: u32,
pub ProcessorMhzLimit: u32,
pub ProcessorMaxIdleState: u32,
pub ProcessorCurrentIdleState: u32,
pub ProcessIntegrityLevel: u32,
pub ProcessExecuteFlags: u32,
pub ProtectedProcess: u32,
pub TimeZoneId: u32,
pub TimeZone: super::super::Time::TIME_ZONE_INFORMATION,
pub BuildString: [u16; 260],
pub DbgBldStr: [u16; 40],
pub XStateData: XSTATE_CONFIG_FEATURE_MSC_INFO,
pub ProcessCookie: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl MINIDUMP_MISC_INFO_5 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::default::Default for MINIDUMP_MISC_INFO_5 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::PartialEq for MINIDUMP_MISC_INFO_5 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
impl ::core::cmp::Eq for MINIDUMP_MISC_INFO_5 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Time"))]
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO_5 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_MISC_INFO_FLAGS(pub u32);
pub const MINIDUMP_MISC1_PROCESS_ID: MINIDUMP_MISC_INFO_FLAGS = MINIDUMP_MISC_INFO_FLAGS(1u32);
pub const MINIDUMP_MISC1_PROCESS_TIMES: MINIDUMP_MISC_INFO_FLAGS = MINIDUMP_MISC_INFO_FLAGS(2u32);
impl ::core::convert::From<u32> for MINIDUMP_MISC_INFO_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_MISC_INFO_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for MINIDUMP_MISC_INFO_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MINIDUMP_MISC_INFO_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MINIDUMP_MISC_INFO_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MINIDUMP_MISC_INFO_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MINIDUMP_MISC_INFO_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(feature = "Win32_Storage_FileSystem")]
pub struct MINIDUMP_MODULE {
pub BaseOfImage: u64,
pub SizeOfImage: u32,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub ModuleNameRva: u32,
pub VersionInfo: super::super::super::Storage::FileSystem::VS_FIXEDFILEINFO,
pub CvRecord: MINIDUMP_LOCATION_DESCRIPTOR,
pub MiscRecord: MINIDUMP_LOCATION_DESCRIPTOR,
pub Reserved0: u64,
pub Reserved1: u64,
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl MINIDUMP_MODULE {}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::default::Default for MINIDUMP_MODULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::cmp::PartialEq for MINIDUMP_MODULE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::cmp::Eq for MINIDUMP_MODULE {}
#[cfg(feature = "Win32_Storage_FileSystem")]
unsafe impl ::windows::core::Abi for MINIDUMP_MODULE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
pub struct MINIDUMP_MODULE_CALLBACK {
pub FullPath: super::super::super::Foundation::PWSTR,
pub BaseOfImage: u64,
pub SizeOfImage: u32,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub VersionInfo: super::super::super::Storage::FileSystem::VS_FIXEDFILEINFO,
pub CvRecord: *mut ::core::ffi::c_void,
pub SizeOfCvRecord: u32,
pub MiscRecord: *mut ::core::ffi::c_void,
pub SizeOfMiscRecord: u32,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
impl MINIDUMP_MODULE_CALLBACK {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
impl ::core::default::Default for MINIDUMP_MODULE_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
impl ::core::cmp::PartialEq for MINIDUMP_MODULE_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
impl ::core::cmp::Eq for MINIDUMP_MODULE_CALLBACK {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem"))]
unsafe impl ::windows::core::Abi for MINIDUMP_MODULE_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Storage_FileSystem")]
pub struct MINIDUMP_MODULE_LIST {
pub NumberOfModules: u32,
pub Modules: [MINIDUMP_MODULE; 1],
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl MINIDUMP_MODULE_LIST {}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::default::Default for MINIDUMP_MODULE_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::cmp::PartialEq for MINIDUMP_MODULE_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Storage_FileSystem")]
impl ::core::cmp::Eq for MINIDUMP_MODULE_LIST {}
#[cfg(feature = "Win32_Storage_FileSystem")]
unsafe impl ::windows::core::Abi for MINIDUMP_MODULE_LIST {
type Abi = Self;
}
pub const MINIDUMP_PROCESS_VM_COUNTERS: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_PROCESS_VM_COUNTERS_1 {
pub Revision: u16,
pub PageFaultCount: u32,
pub PeakWorkingSetSize: u64,
pub WorkingSetSize: u64,
pub QuotaPeakPagedPoolUsage: u64,
pub QuotaPagedPoolUsage: u64,
pub QuotaPeakNonPagedPoolUsage: u64,
pub QuotaNonPagedPoolUsage: u64,
pub PagefileUsage: u64,
pub PeakPagefileUsage: u64,
pub PrivateUsage: u64,
}
impl MINIDUMP_PROCESS_VM_COUNTERS_1 {}
impl ::core::default::Default for MINIDUMP_PROCESS_VM_COUNTERS_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_PROCESS_VM_COUNTERS_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_PROCESS_VM_COUNTERS_1 {}
unsafe impl ::windows::core::Abi for MINIDUMP_PROCESS_VM_COUNTERS_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_PROCESS_VM_COUNTERS_2 {
pub Revision: u16,
pub Flags: u16,
pub PageFaultCount: u32,
pub PeakWorkingSetSize: u64,
pub WorkingSetSize: u64,
pub QuotaPeakPagedPoolUsage: u64,
pub QuotaPagedPoolUsage: u64,
pub QuotaPeakNonPagedPoolUsage: u64,
pub QuotaNonPagedPoolUsage: u64,
pub PagefileUsage: u64,
pub PeakPagefileUsage: u64,
pub PeakVirtualSize: u64,
pub VirtualSize: u64,
pub PrivateUsage: u64,
pub PrivateWorkingSetSize: u64,
pub SharedCommitUsage: u64,
pub JobSharedCommitUsage: u64,
pub JobPrivateCommitUsage: u64,
pub JobPeakPrivateCommitUsage: u64,
pub JobPrivateCommitLimit: u64,
pub JobTotalCommitLimit: u64,
}
impl MINIDUMP_PROCESS_VM_COUNTERS_2 {}
impl ::core::default::Default for MINIDUMP_PROCESS_VM_COUNTERS_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_PROCESS_VM_COUNTERS_2 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_PROCESS_VM_COUNTERS_2 {}
unsafe impl ::windows::core::Abi for MINIDUMP_PROCESS_VM_COUNTERS_2 {
type Abi = Self;
}
pub const MINIDUMP_PROCESS_VM_COUNTERS_EX: u32 = 4u32;
pub const MINIDUMP_PROCESS_VM_COUNTERS_EX2: u32 = 8u32;
pub const MINIDUMP_PROCESS_VM_COUNTERS_JOB: u32 = 16u32;
pub const MINIDUMP_PROCESS_VM_COUNTERS_VIRTUALSIZE: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {
pub Offset: u64,
pub Bytes: u32,
pub FailureStatus: ::windows::core::HRESULT,
}
impl MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {}
impl ::core::default::Default for MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_READ_MEMORY_FAILURE_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_SECONDARY_FLAGS(pub i32);
pub const MiniSecondaryWithoutPowerInfo: MINIDUMP_SECONDARY_FLAGS = MINIDUMP_SECONDARY_FLAGS(1i32);
pub const MiniSecondaryValidFlags: MINIDUMP_SECONDARY_FLAGS = MINIDUMP_SECONDARY_FLAGS(1i32);
impl ::core::convert::From<i32> for MINIDUMP_SECONDARY_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_SECONDARY_FLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_STREAM_TYPE(pub i32);
pub const UnusedStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(0i32);
pub const ReservedStream0: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(1i32);
pub const ReservedStream1: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(2i32);
pub const ThreadListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(3i32);
pub const ModuleListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(4i32);
pub const MemoryListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(5i32);
pub const ExceptionStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(6i32);
pub const SystemInfoStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(7i32);
pub const ThreadExListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(8i32);
pub const Memory64ListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(9i32);
pub const CommentStreamA: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(10i32);
pub const CommentStreamW: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(11i32);
pub const HandleDataStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(12i32);
pub const FunctionTableStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(13i32);
pub const UnloadedModuleListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(14i32);
pub const MiscInfoStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(15i32);
pub const MemoryInfoListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(16i32);
pub const ThreadInfoListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(17i32);
pub const HandleOperationListStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(18i32);
pub const TokenStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(19i32);
pub const JavaScriptDataStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(20i32);
pub const SystemMemoryInfoStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(21i32);
pub const ProcessVmCountersStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(22i32);
pub const IptTraceStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(23i32);
pub const ThreadNamesStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(24i32);
pub const ceStreamNull: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32768i32);
pub const ceStreamSystemInfo: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32769i32);
pub const ceStreamException: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32770i32);
pub const ceStreamModuleList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32771i32);
pub const ceStreamProcessList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32772i32);
pub const ceStreamThreadList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32773i32);
pub const ceStreamThreadContextList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32774i32);
pub const ceStreamThreadCallStackList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32775i32);
pub const ceStreamMemoryVirtualList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32776i32);
pub const ceStreamMemoryPhysicalList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32777i32);
pub const ceStreamBucketParameters: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32778i32);
pub const ceStreamProcessModuleMap: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32779i32);
pub const ceStreamDiagnosisList: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(32780i32);
pub const LastReservedStream: MINIDUMP_STREAM_TYPE = MINIDUMP_STREAM_TYPE(65535i32);
impl ::core::convert::From<i32> for MINIDUMP_STREAM_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_STREAM_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_STRING {
pub Length: u32,
pub Buffer: [u16; 1],
}
impl MINIDUMP_STRING {}
impl ::core::default::Default for MINIDUMP_STRING {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_STRING {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_STRING").field("Length", &self.Length).field("Buffer", &self.Buffer).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_STRING {
fn eq(&self, other: &Self) -> bool {
self.Length == other.Length && self.Buffer == other.Buffer
}
}
impl ::core::cmp::Eq for MINIDUMP_STRING {}
unsafe impl ::windows::core::Abi for MINIDUMP_STRING {
type Abi = Self;
}
pub const MINIDUMP_SYSMEMINFO1_BASICPERF: u32 = 2u32;
pub const MINIDUMP_SYSMEMINFO1_FILECACHE_TRANSITIONREPURPOSECOUNT_FLAGS: u32 = 1u32;
pub const MINIDUMP_SYSMEMINFO1_PERF_CCTOTALDIRTYPAGES_CCDIRTYPAGETHRESHOLD: u32 = 4u32;
pub const MINIDUMP_SYSMEMINFO1_PERF_RESIDENTAVAILABLEPAGES_SHAREDCOMMITPAGES: u32 = 8u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_SYSTEM_BASIC_INFORMATION {
pub TimerResolution: u32,
pub PageSize: u32,
pub NumberOfPhysicalPages: u32,
pub LowestPhysicalPageNumber: u32,
pub HighestPhysicalPageNumber: u32,
pub AllocationGranularity: u32,
pub MinimumUserModeAddress: u64,
pub MaximumUserModeAddress: u64,
pub ActiveProcessorsAffinityMask: u64,
pub NumberOfProcessors: u32,
}
impl MINIDUMP_SYSTEM_BASIC_INFORMATION {}
impl ::core::default::Default for MINIDUMP_SYSTEM_BASIC_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_BASIC_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_BASIC_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_BASIC_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {
pub AvailablePages: u64,
pub CommittedPages: u64,
pub CommitLimit: u64,
pub PeakCommitment: u64,
}
impl MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {}
impl ::core::default::Default for MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_SYSTEM_FILECACHE_INFORMATION {
pub CurrentSize: u64,
pub PeakSize: u64,
pub PageFaultCount: u32,
pub MinimumWorkingSet: u64,
pub MaximumWorkingSet: u64,
pub CurrentSizeIncludingTransitionInPages: u64,
pub PeakSizeIncludingTransitionInPages: u64,
pub TransitionRePurposeCount: u32,
pub Flags: u32,
}
impl MINIDUMP_SYSTEM_FILECACHE_INFORMATION {}
impl ::core::default::Default for MINIDUMP_SYSTEM_FILECACHE_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_FILECACHE_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_FILECACHE_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_FILECACHE_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_SYSTEM_INFO {
pub ProcessorArchitecture: PROCESSOR_ARCHITECTURE,
pub ProcessorLevel: u16,
pub ProcessorRevision: u16,
pub Anonymous1: MINIDUMP_SYSTEM_INFO_0,
pub MajorVersion: u32,
pub MinorVersion: u32,
pub BuildNumber: u32,
pub PlatformId: VER_PLATFORM,
pub CSDVersionRva: u32,
pub Anonymous2: MINIDUMP_SYSTEM_INFO_1,
pub Cpu: CPU_INFORMATION,
}
impl MINIDUMP_SYSTEM_INFO {}
impl ::core::default::Default for MINIDUMP_SYSTEM_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_INFO {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union MINIDUMP_SYSTEM_INFO_0 {
pub Reserved0: u16,
pub Anonymous: MINIDUMP_SYSTEM_INFO_0_0,
}
impl MINIDUMP_SYSTEM_INFO_0 {}
impl ::core::default::Default for MINIDUMP_SYSTEM_INFO_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_INFO_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_INFO_0 {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_INFO_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_SYSTEM_INFO_0_0 {
pub NumberOfProcessors: u8,
pub ProductType: u8,
}
impl MINIDUMP_SYSTEM_INFO_0_0 {}
impl ::core::default::Default for MINIDUMP_SYSTEM_INFO_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_SYSTEM_INFO_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("NumberOfProcessors", &self.NumberOfProcessors).field("ProductType", &self.ProductType).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_INFO_0_0 {
fn eq(&self, other: &Self) -> bool {
self.NumberOfProcessors == other.NumberOfProcessors && self.ProductType == other.ProductType
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_INFO_0_0 {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_INFO_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union MINIDUMP_SYSTEM_INFO_1 {
pub Reserved1: u32,
pub Anonymous: MINIDUMP_SYSTEM_INFO_1_0,
}
impl MINIDUMP_SYSTEM_INFO_1 {}
impl ::core::default::Default for MINIDUMP_SYSTEM_INFO_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_INFO_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_INFO_1 {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_INFO_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_SYSTEM_INFO_1_0 {
pub SuiteMask: u16,
pub Reserved2: u16,
}
impl MINIDUMP_SYSTEM_INFO_1_0 {}
impl ::core::default::Default for MINIDUMP_SYSTEM_INFO_1_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_SYSTEM_INFO_1_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("SuiteMask", &self.SuiteMask).field("Reserved2", &self.Reserved2).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_INFO_1_0 {
fn eq(&self, other: &Self) -> bool {
self.SuiteMask == other.SuiteMask && self.Reserved2 == other.Reserved2
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_INFO_1_0 {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_INFO_1_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_SYSTEM_MEMORY_INFO_1 {
pub Revision: u16,
pub Flags: u16,
pub BasicInfo: MINIDUMP_SYSTEM_BASIC_INFORMATION,
pub FileCacheInfo: MINIDUMP_SYSTEM_FILECACHE_INFORMATION,
pub BasicPerfInfo: MINIDUMP_SYSTEM_BASIC_PERFORMANCE_INFORMATION,
pub PerfInfo: MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION,
}
impl MINIDUMP_SYSTEM_MEMORY_INFO_1 {}
impl ::core::default::Default for MINIDUMP_SYSTEM_MEMORY_INFO_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_MEMORY_INFO_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_MEMORY_INFO_1 {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_MEMORY_INFO_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {
pub IdleProcessTime: u64,
pub IoReadTransferCount: u64,
pub IoWriteTransferCount: u64,
pub IoOtherTransferCount: u64,
pub IoReadOperationCount: u32,
pub IoWriteOperationCount: u32,
pub IoOtherOperationCount: u32,
pub AvailablePages: u32,
pub CommittedPages: u32,
pub CommitLimit: u32,
pub PeakCommitment: u32,
pub PageFaultCount: u32,
pub CopyOnWriteCount: u32,
pub TransitionCount: u32,
pub CacheTransitionCount: u32,
pub DemandZeroCount: u32,
pub PageReadCount: u32,
pub PageReadIoCount: u32,
pub CacheReadCount: u32,
pub CacheIoCount: u32,
pub DirtyPagesWriteCount: u32,
pub DirtyWriteIoCount: u32,
pub MappedPagesWriteCount: u32,
pub MappedWriteIoCount: u32,
pub PagedPoolPages: u32,
pub NonPagedPoolPages: u32,
pub PagedPoolAllocs: u32,
pub PagedPoolFrees: u32,
pub NonPagedPoolAllocs: u32,
pub NonPagedPoolFrees: u32,
pub FreeSystemPtes: u32,
pub ResidentSystemCodePage: u32,
pub TotalSystemDriverPages: u32,
pub TotalSystemCodePages: u32,
pub NonPagedPoolLookasideHits: u32,
pub PagedPoolLookasideHits: u32,
pub AvailablePagedPoolPages: u32,
pub ResidentSystemCachePage: u32,
pub ResidentPagedPoolPage: u32,
pub ResidentSystemDriverPage: u32,
pub CcFastReadNoWait: u32,
pub CcFastReadWait: u32,
pub CcFastReadResourceMiss: u32,
pub CcFastReadNotPossible: u32,
pub CcFastMdlReadNoWait: u32,
pub CcFastMdlReadWait: u32,
pub CcFastMdlReadResourceMiss: u32,
pub CcFastMdlReadNotPossible: u32,
pub CcMapDataNoWait: u32,
pub CcMapDataWait: u32,
pub CcMapDataNoWaitMiss: u32,
pub CcMapDataWaitMiss: u32,
pub CcPinMappedDataCount: u32,
pub CcPinReadNoWait: u32,
pub CcPinReadWait: u32,
pub CcPinReadNoWaitMiss: u32,
pub CcPinReadWaitMiss: u32,
pub CcCopyReadNoWait: u32,
pub CcCopyReadWait: u32,
pub CcCopyReadNoWaitMiss: u32,
pub CcCopyReadWaitMiss: u32,
pub CcMdlReadNoWait: u32,
pub CcMdlReadWait: u32,
pub CcMdlReadNoWaitMiss: u32,
pub CcMdlReadWaitMiss: u32,
pub CcReadAheadIos: u32,
pub CcLazyWriteIos: u32,
pub CcLazyWritePages: u32,
pub CcDataFlushes: u32,
pub CcDataPages: u32,
pub ContextSwitches: u32,
pub FirstLevelTbFills: u32,
pub SecondLevelTbFills: u32,
pub SystemCalls: u32,
pub CcTotalDirtyPages: u64,
pub CcDirtyPageThreshold: u64,
pub ResidentAvailablePages: i64,
pub SharedCommittedPages: u64,
}
impl MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {}
impl ::core::default::Default for MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_SYSTEM_PERFORMANCE_INFORMATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_THREAD {
pub ThreadId: u32,
pub SuspendCount: u32,
pub PriorityClass: u32,
pub Priority: u32,
pub Teb: u64,
pub Stack: MINIDUMP_MEMORY_DESCRIPTOR,
pub ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR,
}
impl MINIDUMP_THREAD {}
impl ::core::default::Default for MINIDUMP_THREAD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Pad: u32,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_CALLBACK {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_THREAD_EX {
pub ThreadId: u32,
pub SuspendCount: u32,
pub PriorityClass: u32,
pub Priority: u32,
pub Teb: u64,
pub Stack: MINIDUMP_MEMORY_DESCRIPTOR,
pub ThreadContext: MINIDUMP_LOCATION_DESCRIPTOR,
pub BackingStore: MINIDUMP_MEMORY_DESCRIPTOR,
}
impl MINIDUMP_THREAD_EX {}
impl ::core::default::Default for MINIDUMP_THREAD_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_EX {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_EX {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_EX {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_EX_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Pad: u32,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
pub BackingStoreBase: u64,
pub BackingStoreEnd: u64,
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_EX_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_EX_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_EX_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_EX_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
pub BackingStoreBase: u64,
pub BackingStoreEnd: u64,
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_EX_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_EX_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_EX_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct MINIDUMP_THREAD_EX_CALLBACK {
pub ThreadId: u32,
pub ThreadHandle: super::super::super::Foundation::HANDLE,
pub Context: CONTEXT,
pub SizeOfContext: u32,
pub StackBase: u64,
pub StackEnd: u64,
pub BackingStoreBase: u64,
pub BackingStoreEnd: u64,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for MINIDUMP_THREAD_EX_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_EX_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for MINIDUMP_THREAD_EX_CALLBACK {}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_EX_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_THREAD_EX_LIST {
pub NumberOfThreads: u32,
pub Threads: [MINIDUMP_THREAD_EX; 1],
}
impl MINIDUMP_THREAD_EX_LIST {}
impl ::core::default::Default for MINIDUMP_THREAD_EX_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_EX_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_EX_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_EX_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_THREAD_INFO {
pub ThreadId: u32,
pub DumpFlags: MINIDUMP_THREAD_INFO_DUMP_FLAGS,
pub DumpError: u32,
pub ExitStatus: u32,
pub CreateTime: u64,
pub ExitTime: u64,
pub KernelTime: u64,
pub UserTime: u64,
pub StartAddress: u64,
pub Affinity: u64,
}
impl MINIDUMP_THREAD_INFO {}
impl ::core::default::Default for MINIDUMP_THREAD_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_INFO {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_THREAD_INFO_DUMP_FLAGS(pub u32);
pub const MINIDUMP_THREAD_INFO_ERROR_THREAD: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(1u32);
pub const MINIDUMP_THREAD_INFO_EXITED_THREAD: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(4u32);
pub const MINIDUMP_THREAD_INFO_INVALID_CONTEXT: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(16u32);
pub const MINIDUMP_THREAD_INFO_INVALID_INFO: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(8u32);
pub const MINIDUMP_THREAD_INFO_INVALID_TEB: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(32u32);
pub const MINIDUMP_THREAD_INFO_WRITING_THREAD: MINIDUMP_THREAD_INFO_DUMP_FLAGS = MINIDUMP_THREAD_INFO_DUMP_FLAGS(2u32);
impl ::core::convert::From<u32> for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MINIDUMP_THREAD_INFO_DUMP_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_THREAD_INFO_LIST {
pub SizeOfHeader: u32,
pub SizeOfEntry: u32,
pub NumberOfEntries: u32,
}
impl MINIDUMP_THREAD_INFO_LIST {}
impl ::core::default::Default for MINIDUMP_THREAD_INFO_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_THREAD_INFO_LIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_THREAD_INFO_LIST").field("SizeOfHeader", &self.SizeOfHeader).field("SizeOfEntry", &self.SizeOfEntry).field("NumberOfEntries", &self.NumberOfEntries).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_INFO_LIST {
fn eq(&self, other: &Self) -> bool {
self.SizeOfHeader == other.SizeOfHeader && self.SizeOfEntry == other.SizeOfEntry && self.NumberOfEntries == other.NumberOfEntries
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_INFO_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_INFO_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_THREAD_LIST {
pub NumberOfThreads: u32,
pub Threads: [MINIDUMP_THREAD; 1],
}
impl MINIDUMP_THREAD_LIST {}
impl ::core::default::Default for MINIDUMP_THREAD_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_THREAD_NAME {
pub ThreadId: u32,
pub RvaOfThreadName: u64,
}
impl MINIDUMP_THREAD_NAME {}
impl ::core::default::Default for MINIDUMP_THREAD_NAME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_NAME {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_NAME {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_NAME {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_THREAD_NAME_LIST {
pub NumberOfThreadNames: u32,
pub ThreadNames: [MINIDUMP_THREAD_NAME; 1],
}
impl MINIDUMP_THREAD_NAME_LIST {}
impl ::core::default::Default for MINIDUMP_THREAD_NAME_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_THREAD_NAME_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_THREAD_NAME_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_THREAD_NAME_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_TOKEN_INFO_HEADER {
pub TokenSize: u32,
pub TokenId: u32,
pub TokenHandle: u64,
}
impl MINIDUMP_TOKEN_INFO_HEADER {}
impl ::core::default::Default for MINIDUMP_TOKEN_INFO_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_TOKEN_INFO_HEADER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_TOKEN_INFO_HEADER {}
unsafe impl ::windows::core::Abi for MINIDUMP_TOKEN_INFO_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_TOKEN_INFO_LIST {
pub TokenListSize: u32,
pub TokenListEntries: u32,
pub ListHeaderSize: u32,
pub ElementHeaderSize: u32,
}
impl MINIDUMP_TOKEN_INFO_LIST {}
impl ::core::default::Default for MINIDUMP_TOKEN_INFO_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_TOKEN_INFO_LIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_TOKEN_INFO_LIST").field("TokenListSize", &self.TokenListSize).field("TokenListEntries", &self.TokenListEntries).field("ListHeaderSize", &self.ListHeaderSize).field("ElementHeaderSize", &self.ElementHeaderSize).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_TOKEN_INFO_LIST {
fn eq(&self, other: &Self) -> bool {
self.TokenListSize == other.TokenListSize && self.TokenListEntries == other.TokenListEntries && self.ListHeaderSize == other.ListHeaderSize && self.ElementHeaderSize == other.ElementHeaderSize
}
}
impl ::core::cmp::Eq for MINIDUMP_TOKEN_INFO_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_TOKEN_INFO_LIST {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MINIDUMP_TYPE(pub u32);
pub const MiniDumpNormal: MINIDUMP_TYPE = MINIDUMP_TYPE(0u32);
pub const MiniDumpWithDataSegs: MINIDUMP_TYPE = MINIDUMP_TYPE(1u32);
pub const MiniDumpWithFullMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(2u32);
pub const MiniDumpWithHandleData: MINIDUMP_TYPE = MINIDUMP_TYPE(4u32);
pub const MiniDumpFilterMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(8u32);
pub const MiniDumpScanMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(16u32);
pub const MiniDumpWithUnloadedModules: MINIDUMP_TYPE = MINIDUMP_TYPE(32u32);
pub const MiniDumpWithIndirectlyReferencedMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(64u32);
pub const MiniDumpFilterModulePaths: MINIDUMP_TYPE = MINIDUMP_TYPE(128u32);
pub const MiniDumpWithProcessThreadData: MINIDUMP_TYPE = MINIDUMP_TYPE(256u32);
pub const MiniDumpWithPrivateReadWriteMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(512u32);
pub const MiniDumpWithoutOptionalData: MINIDUMP_TYPE = MINIDUMP_TYPE(1024u32);
pub const MiniDumpWithFullMemoryInfo: MINIDUMP_TYPE = MINIDUMP_TYPE(2048u32);
pub const MiniDumpWithThreadInfo: MINIDUMP_TYPE = MINIDUMP_TYPE(4096u32);
pub const MiniDumpWithCodeSegs: MINIDUMP_TYPE = MINIDUMP_TYPE(8192u32);
pub const MiniDumpWithoutAuxiliaryState: MINIDUMP_TYPE = MINIDUMP_TYPE(16384u32);
pub const MiniDumpWithFullAuxiliaryState: MINIDUMP_TYPE = MINIDUMP_TYPE(32768u32);
pub const MiniDumpWithPrivateWriteCopyMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(65536u32);
pub const MiniDumpIgnoreInaccessibleMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(131072u32);
pub const MiniDumpWithTokenInformation: MINIDUMP_TYPE = MINIDUMP_TYPE(262144u32);
pub const MiniDumpWithModuleHeaders: MINIDUMP_TYPE = MINIDUMP_TYPE(524288u32);
pub const MiniDumpFilterTriage: MINIDUMP_TYPE = MINIDUMP_TYPE(1048576u32);
pub const MiniDumpWithAvxXStateContext: MINIDUMP_TYPE = MINIDUMP_TYPE(2097152u32);
pub const MiniDumpWithIptTrace: MINIDUMP_TYPE = MINIDUMP_TYPE(4194304u32);
pub const MiniDumpScanInaccessiblePartialPages: MINIDUMP_TYPE = MINIDUMP_TYPE(8388608u32);
pub const MiniDumpFilterWriteCombinedMemory: MINIDUMP_TYPE = MINIDUMP_TYPE(16777216u32);
pub const MiniDumpValidTypeFlags: MINIDUMP_TYPE = MINIDUMP_TYPE(33554431u32);
impl ::core::convert::From<u32> for MINIDUMP_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MINIDUMP_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for MINIDUMP_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MINIDUMP_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MINIDUMP_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MINIDUMP_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MINIDUMP_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_UNLOADED_MODULE {
pub BaseOfImage: u64,
pub SizeOfImage: u32,
pub CheckSum: u32,
pub TimeDateStamp: u32,
pub ModuleNameRva: u32,
}
impl MINIDUMP_UNLOADED_MODULE {}
impl ::core::default::Default for MINIDUMP_UNLOADED_MODULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_UNLOADED_MODULE {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_UNLOADED_MODULE {}
unsafe impl ::windows::core::Abi for MINIDUMP_UNLOADED_MODULE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_UNLOADED_MODULE_LIST {
pub SizeOfHeader: u32,
pub SizeOfEntry: u32,
pub NumberOfEntries: u32,
}
impl MINIDUMP_UNLOADED_MODULE_LIST {}
impl ::core::default::Default for MINIDUMP_UNLOADED_MODULE_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_UNLOADED_MODULE_LIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_UNLOADED_MODULE_LIST").field("SizeOfHeader", &self.SizeOfHeader).field("SizeOfEntry", &self.SizeOfEntry).field("NumberOfEntries", &self.NumberOfEntries).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_UNLOADED_MODULE_LIST {
fn eq(&self, other: &Self) -> bool {
self.SizeOfHeader == other.SizeOfHeader && self.SizeOfEntry == other.SizeOfEntry && self.NumberOfEntries == other.NumberOfEntries
}
}
impl ::core::cmp::Eq for MINIDUMP_UNLOADED_MODULE_LIST {}
unsafe impl ::windows::core::Abi for MINIDUMP_UNLOADED_MODULE_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MINIDUMP_USER_RECORD {
pub Type: u32,
pub Memory: MINIDUMP_LOCATION_DESCRIPTOR,
}
impl MINIDUMP_USER_RECORD {}
impl ::core::default::Default for MINIDUMP_USER_RECORD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MINIDUMP_USER_RECORD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MINIDUMP_USER_RECORD").field("Type", &self.Type).field("Memory", &self.Memory).finish()
}
}
impl ::core::cmp::PartialEq for MINIDUMP_USER_RECORD {
fn eq(&self, other: &Self) -> bool {
self.Type == other.Type && self.Memory == other.Memory
}
}
impl ::core::cmp::Eq for MINIDUMP_USER_RECORD {}
unsafe impl ::windows::core::Abi for MINIDUMP_USER_RECORD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_USER_STREAM {
pub Type: u32,
pub BufferSize: u32,
pub Buffer: *mut ::core::ffi::c_void,
}
impl MINIDUMP_USER_STREAM {}
impl ::core::default::Default for MINIDUMP_USER_STREAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_USER_STREAM {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_USER_STREAM {}
unsafe impl ::windows::core::Abi for MINIDUMP_USER_STREAM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_USER_STREAM_INFORMATION {
pub UserStreamCount: u32,
pub UserStreamArray: *mut MINIDUMP_USER_STREAM,
}
impl MINIDUMP_USER_STREAM_INFORMATION {}
impl ::core::default::Default for MINIDUMP_USER_STREAM_INFORMATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_USER_STREAM_INFORMATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_USER_STREAM_INFORMATION {}
unsafe impl ::windows::core::Abi for MINIDUMP_USER_STREAM_INFORMATION {
type Abi = Self;
}
pub const MINIDUMP_VERSION: u32 = 42899u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_VM_POST_READ_CALLBACK {
pub Offset: u64,
pub Buffer: *mut ::core::ffi::c_void,
pub Size: u32,
pub Completed: u32,
pub Status: ::windows::core::HRESULT,
}
impl MINIDUMP_VM_POST_READ_CALLBACK {}
impl ::core::default::Default for MINIDUMP_VM_POST_READ_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_VM_POST_READ_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_VM_POST_READ_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_VM_POST_READ_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_VM_PRE_READ_CALLBACK {
pub Offset: u64,
pub Buffer: *mut ::core::ffi::c_void,
pub Size: u32,
}
impl MINIDUMP_VM_PRE_READ_CALLBACK {}
impl ::core::default::Default for MINIDUMP_VM_PRE_READ_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_VM_PRE_READ_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_VM_PRE_READ_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_VM_PRE_READ_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct MINIDUMP_VM_QUERY_CALLBACK {
pub Offset: u64,
}
impl MINIDUMP_VM_QUERY_CALLBACK {}
impl ::core::default::Default for MINIDUMP_VM_QUERY_CALLBACK {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for MINIDUMP_VM_QUERY_CALLBACK {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for MINIDUMP_VM_QUERY_CALLBACK {}
unsafe impl ::windows::core::Abi for MINIDUMP_VM_QUERY_CALLBACK {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MODLOAD_CVMISC {
pub oCV: u32,
pub cCV: usize,
pub oMisc: u32,
pub cMisc: usize,
pub dtImage: u32,
pub cImage: u32,
}
impl MODLOAD_CVMISC {}
impl ::core::default::Default for MODLOAD_CVMISC {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MODLOAD_CVMISC {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MODLOAD_CVMISC").field("oCV", &self.oCV).field("cCV", &self.cCV).field("oMisc", &self.oMisc).field("cMisc", &self.cMisc).field("dtImage", &self.dtImage).field("cImage", &self.cImage).finish()
}
}
impl ::core::cmp::PartialEq for MODLOAD_CVMISC {
fn eq(&self, other: &Self) -> bool {
self.oCV == other.oCV && self.cCV == other.cCV && self.oMisc == other.oMisc && self.cMisc == other.cMisc && self.dtImage == other.dtImage && self.cImage == other.cImage
}
}
impl ::core::cmp::Eq for MODLOAD_CVMISC {}
unsafe impl ::windows::core::Abi for MODLOAD_CVMISC {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MODLOAD_DATA {
pub ssize: u32,
pub ssig: MODLOAD_DATA_TYPE,
pub data: *mut ::core::ffi::c_void,
pub size: u32,
pub flags: u32,
}
impl MODLOAD_DATA {}
impl ::core::default::Default for MODLOAD_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MODLOAD_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MODLOAD_DATA").field("ssize", &self.ssize).field("ssig", &self.ssig).field("data", &self.data).field("size", &self.size).field("flags", &self.flags).finish()
}
}
impl ::core::cmp::PartialEq for MODLOAD_DATA {
fn eq(&self, other: &Self) -> bool {
self.ssize == other.ssize && self.ssig == other.ssig && self.data == other.data && self.size == other.size && self.flags == other.flags
}
}
impl ::core::cmp::Eq for MODLOAD_DATA {}
unsafe impl ::windows::core::Abi for MODLOAD_DATA {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MODLOAD_DATA_TYPE(pub u32);
pub const DBHHEADER_DEBUGDIRS: MODLOAD_DATA_TYPE = MODLOAD_DATA_TYPE(1u32);
pub const DBHHEADER_CVMISC: MODLOAD_DATA_TYPE = MODLOAD_DATA_TYPE(2u32);
impl ::core::convert::From<u32> for MODLOAD_DATA_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MODLOAD_DATA_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for MODLOAD_DATA_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for MODLOAD_DATA_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for MODLOAD_DATA_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for MODLOAD_DATA_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for MODLOAD_DATA_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MODLOAD_PDBGUID_PDBAGE {
pub PdbGuid: ::windows::core::GUID,
pub PdbAge: u32,
}
impl MODLOAD_PDBGUID_PDBAGE {}
impl ::core::default::Default for MODLOAD_PDBGUID_PDBAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MODLOAD_PDBGUID_PDBAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MODLOAD_PDBGUID_PDBAGE").field("PdbGuid", &self.PdbGuid).field("PdbAge", &self.PdbAge).finish()
}
}
impl ::core::cmp::PartialEq for MODLOAD_PDBGUID_PDBAGE {
fn eq(&self, other: &Self) -> bool {
self.PdbGuid == other.PdbGuid && self.PdbAge == other.PdbAge
}
}
impl ::core::cmp::Eq for MODLOAD_PDBGUID_PDBAGE {}
unsafe impl ::windows::core::Abi for MODLOAD_PDBGUID_PDBAGE {
type Abi = Self;
}
pub const MODULE_ORDERS_LOADTIME: u32 = 268435456u32;
pub const MODULE_ORDERS_MASK: u32 = 4026531840u32;
pub const MODULE_ORDERS_MODULENAME: u32 = 536870912u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct MODULE_TYPE_INFO {
pub dataLength: u16,
pub leaf: u16,
pub data: [u8; 1],
}
impl MODULE_TYPE_INFO {}
impl ::core::default::Default for MODULE_TYPE_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for MODULE_TYPE_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("MODULE_TYPE_INFO").field("dataLength", &self.dataLength).field("leaf", &self.leaf).field("data", &self.data).finish()
}
}
impl ::core::cmp::PartialEq for MODULE_TYPE_INFO {
fn eq(&self, other: &Self) -> bool {
self.dataLength == other.dataLength && self.leaf == other.leaf && self.data == other.data
}
}
impl ::core::cmp::Eq for MODULE_TYPE_INFO {}
unsafe impl ::windows::core::Abi for MODULE_TYPE_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct MODULE_WRITE_FLAGS(pub i32);
pub const ModuleWriteModule: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(1i32);
pub const ModuleWriteDataSeg: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(2i32);
pub const ModuleWriteMiscRecord: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(4i32);
pub const ModuleWriteCvRecord: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(8i32);
pub const ModuleReferencedByMemory: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(16i32);
pub const ModuleWriteTlsData: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(32i32);
pub const ModuleWriteCodeSegs: MODULE_WRITE_FLAGS = MODULE_WRITE_FLAGS(64i32);
impl ::core::convert::From<i32> for MODULE_WRITE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for MODULE_WRITE_FLAGS {
type Abi = Self;
}
pub const MachineDebugManager_DEBUG: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x49769cec_3a55_4bb0_b697_88fede77e8ea);
pub const MachineDebugManager_RETAIL: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0c0a3666_30c9_11d0_8f20_00805f2cd064);
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MakeSureDirectoryPathExists<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(dirpath: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MakeSureDirectoryPathExists(dirpath: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(MakeSureDirectoryPathExists(dirpath.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn MapAndLoad<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(imagename: Param0, dllpath: Param1, loadedimage: *mut LOADED_IMAGE, dotdll: Param3, readonly: Param4) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MapAndLoad(imagename: super::super::super::Foundation::PSTR, dllpath: super::super::super::Foundation::PSTR, loadedimage: *mut LOADED_IMAGE, dotdll: super::super::super::Foundation::BOOL, readonly: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(MapAndLoad(imagename.into_param().abi(), dllpath.into_param().abi(), ::core::mem::transmute(loadedimage), dotdll.into_param().abi(), readonly.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MapFileAndCheckSumA<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, headersum: *mut u32, checksum: *mut u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MapFileAndCheckSumA(filename: super::super::super::Foundation::PSTR, headersum: *mut u32, checksum: *mut u32) -> u32;
}
::core::mem::transmute(MapFileAndCheckSumA(filename.into_param().abi(), ::core::mem::transmute(headersum), ::core::mem::transmute(checksum)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MapFileAndCheckSumW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(filename: Param0, headersum: *mut u32, checksum: *mut u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MapFileAndCheckSumW(filename: super::super::super::Foundation::PWSTR, headersum: *mut u32, checksum: *mut u32) -> u32;
}
::core::mem::transmute(MapFileAndCheckSumW(filename.into_param().abi(), ::core::mem::transmute(headersum), ::core::mem::transmute(checksum)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MessageBeep(utype: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MessageBeep(utype: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(MessageBeep(::core::mem::transmute(utype)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn MiniDumpReadDumpStream(baseofdump: *const ::core::ffi::c_void, streamnumber: u32, dir: *mut *mut MINIDUMP_DIRECTORY, streampointer: *mut *mut ::core::ffi::c_void, streamsize: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MiniDumpReadDumpStream(baseofdump: *const ::core::ffi::c_void, streamnumber: u32, dir: *mut *mut MINIDUMP_DIRECTORY, streampointer: *mut *mut ::core::ffi::c_void, streamsize: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(MiniDumpReadDumpStream(::core::mem::transmute(baseofdump), ::core::mem::transmute(streamnumber), ::core::mem::transmute(dir), ::core::mem::transmute(streampointer), ::core::mem::transmute(streamsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Storage_FileSystem", feature = "Win32_System_Kernel", feature = "Win32_System_Memory"))]
#[inline]
pub unsafe fn MiniDumpWriteDump<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, processid: u32, hfile: Param2, dumptype: MINIDUMP_TYPE, exceptionparam: *const MINIDUMP_EXCEPTION_INFORMATION, userstreamparam: *const MINIDUMP_USER_STREAM_INFORMATION, callbackparam: *const MINIDUMP_CALLBACK_INFORMATION) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn MiniDumpWriteDump(hprocess: super::super::super::Foundation::HANDLE, processid: u32, hfile: super::super::super::Foundation::HANDLE, dumptype: MINIDUMP_TYPE, exceptionparam: *const MINIDUMP_EXCEPTION_INFORMATION, userstreamparam: *const MINIDUMP_USER_STREAM_INFORMATION, callbackparam: *const ::core::mem::ManuallyDrop<MINIDUMP_CALLBACK_INFORMATION>) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(MiniDumpWriteDump(hprocess.into_param().abi(), ::core::mem::transmute(processid), hfile.into_param().abi(), ::core::mem::transmute(dumptype), ::core::mem::transmute(exceptionparam), ::core::mem::transmute(userstreamparam), ::core::mem::transmute(callbackparam)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ModelObjectKind(pub i32);
pub const ObjectPropertyAccessor: ModelObjectKind = ModelObjectKind(0i32);
pub const ObjectContext: ModelObjectKind = ModelObjectKind(1i32);
pub const ObjectTargetObject: ModelObjectKind = ModelObjectKind(2i32);
pub const ObjectTargetObjectReference: ModelObjectKind = ModelObjectKind(3i32);
pub const ObjectSynthetic: ModelObjectKind = ModelObjectKind(4i32);
pub const ObjectNoValue: ModelObjectKind = ModelObjectKind(5i32);
pub const ObjectError: ModelObjectKind = ModelObjectKind(6i32);
pub const ObjectIntrinsic: ModelObjectKind = ModelObjectKind(7i32);
pub const ObjectMethod: ModelObjectKind = ModelObjectKind(8i32);
pub const ObjectKeyReference: ModelObjectKind = ModelObjectKind(9i32);
impl ::core::convert::From<i32> for ModelObjectKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ModelObjectKind {
type Abi = Self;
}
pub const NULL_FIELD_NAME: u32 = 6u32;
pub const NULL_SYM_DUMP_PARAM: u32 = 5u32;
pub const NUM_SSRVOPTS: u32 = 32u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OBJECT_ATTRIB_FLAG(pub u32);
pub const OBJECT_ATTRIB_NO_ATTRIB: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(0u32);
pub const OBJECT_ATTRIB_NO_NAME: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(1u32);
pub const OBJECT_ATTRIB_NO_TYPE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(2u32);
pub const OBJECT_ATTRIB_NO_VALUE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(4u32);
pub const OBJECT_ATTRIB_VALUE_IS_INVALID: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(8u32);
pub const OBJECT_ATTRIB_VALUE_IS_OBJECT: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(16u32);
pub const OBJECT_ATTRIB_VALUE_IS_ENUM: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(32u32);
pub const OBJECT_ATTRIB_VALUE_IS_CUSTOM: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(64u32);
pub const OBJECT_ATTRIB_OBJECT_IS_EXPANDABLE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(112u32);
pub const OBJECT_ATTRIB_VALUE_HAS_CODE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(128u32);
pub const OBJECT_ATTRIB_TYPE_IS_OBJECT: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(256u32);
pub const OBJECT_ATTRIB_TYPE_HAS_CODE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(512u32);
pub const OBJECT_ATTRIB_TYPE_IS_EXPANDABLE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(256u32);
pub const OBJECT_ATTRIB_SLOT_IS_CATEGORY: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(1024u32);
pub const OBJECT_ATTRIB_VALUE_READONLY: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(2048u32);
pub const OBJECT_ATTRIB_ACCESS_PUBLIC: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(4096u32);
pub const OBJECT_ATTRIB_ACCESS_PRIVATE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(8192u32);
pub const OBJECT_ATTRIB_ACCESS_PROTECTED: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(16384u32);
pub const OBJECT_ATTRIB_ACCESS_FINAL: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(32768u32);
pub const OBJECT_ATTRIB_STORAGE_GLOBAL: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(65536u32);
pub const OBJECT_ATTRIB_STORAGE_STATIC: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(131072u32);
pub const OBJECT_ATTRIB_STORAGE_FIELD: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(262144u32);
pub const OBJECT_ATTRIB_STORAGE_VIRTUAL: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(524288u32);
pub const OBJECT_ATTRIB_TYPE_IS_CONSTANT: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(1048576u32);
pub const OBJECT_ATTRIB_TYPE_IS_SYNCHRONIZED: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(2097152u32);
pub const OBJECT_ATTRIB_TYPE_IS_VOLATILE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(4194304u32);
pub const OBJECT_ATTRIB_HAS_EXTENDED_ATTRIBS: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(8388608u32);
pub const OBJECT_ATTRIB_IS_CLASS: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(16777216u32);
pub const OBJECT_ATTRIB_IS_FUNCTION: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(33554432u32);
pub const OBJECT_ATTRIB_IS_VARIABLE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(67108864u32);
pub const OBJECT_ATTRIB_IS_PROPERTY: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(134217728u32);
pub const OBJECT_ATTRIB_IS_MACRO: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(268435456u32);
pub const OBJECT_ATTRIB_IS_TYPE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(536870912u32);
pub const OBJECT_ATTRIB_IS_INHERITED: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(1073741824u32);
pub const OBJECT_ATTRIB_IS_INTERFACE: OBJECT_ATTRIB_FLAG = OBJECT_ATTRIB_FLAG(2147483648u32);
impl ::core::convert::From<u32> for OBJECT_ATTRIB_FLAG {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OBJECT_ATTRIB_FLAG {
type Abi = Self;
}
impl ::core::ops::BitOr for OBJECT_ATTRIB_FLAG {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OBJECT_ATTRIB_FLAG {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OBJECT_ATTRIB_FLAG {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OBJECT_ATTRIB_FLAG {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OBJECT_ATTRIB_FLAG {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const OID_JSSIP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x06c9e010_38ce_11d4_a2a3_00104bd35090);
pub const OID_VBSSIP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1629f04e_2799_4db5_8fe5_ace10f17ebab);
pub const OID_WSFSIP: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1a610570_38ce_11d4_a2a3_00104bd35090);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct OMAP {
pub rva: u32,
pub rvaTo: u32,
}
impl OMAP {}
impl ::core::default::Default for OMAP {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for OMAP {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OMAP").field("rva", &self.rva).field("rvaTo", &self.rvaTo).finish()
}
}
impl ::core::cmp::PartialEq for OMAP {
fn eq(&self, other: &Self) -> bool {
self.rva == other.rva && self.rvaTo == other.rvaTo
}
}
impl ::core::cmp::Eq for OMAP {}
unsafe impl ::windows::core::Abi for OMAP {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS(pub u32);
pub const WCT_ASYNC_OPEN_FLAG: OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS = OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS(1u32);
impl ::core::convert::From<u32> for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct OUTPUT_DEBUG_STRING_INFO {
pub lpDebugStringData: super::super::super::Foundation::PSTR,
pub fUnicode: u16,
pub nDebugStringLength: u16,
}
#[cfg(feature = "Win32_Foundation")]
impl OUTPUT_DEBUG_STRING_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for OUTPUT_DEBUG_STRING_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for OUTPUT_DEBUG_STRING_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("OUTPUT_DEBUG_STRING_INFO").field("lpDebugStringData", &self.lpDebugStringData).field("fUnicode", &self.fUnicode).field("nDebugStringLength", &self.nDebugStringLength).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for OUTPUT_DEBUG_STRING_INFO {
fn eq(&self, other: &Self) -> bool {
self.lpDebugStringData == other.lpDebugStringData && self.fUnicode == other.fUnicode && self.nDebugStringLength == other.nDebugStringLength
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for OUTPUT_DEBUG_STRING_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for OUTPUT_DEBUG_STRING_INFO {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OpenThreadWaitChainSession(flags: OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS, callback: ::core::option::Option<PWAITCHAINCALLBACK>) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OpenThreadWaitChainSession(flags: OPEN_THREAD_WAIT_CHAIN_SESSION_FLAGS, callback: ::windows::core::RawPtr) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(OpenThreadWaitChainSession(::core::mem::transmute(flags), ::core::mem::transmute(callback)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OutputDebugStringA<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(lpoutputstring: Param0) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OutputDebugStringA(lpoutputstring: super::super::super::Foundation::PSTR);
}
::core::mem::transmute(OutputDebugStringA(lpoutputstring.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn OutputDebugStringW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(lpoutputstring: Param0) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn OutputDebugStringW(lpoutputstring: super::super::super::Foundation::PWSTR);
}
::core::mem::transmute(OutputDebugStringW(lpoutputstring.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
pub type PCOGETACTIVATIONSTATE = unsafe extern "system" fn(param0: ::windows::core::GUID, param1: u32, param2: *mut u32) -> ::windows::core::HRESULT;
pub type PCOGETCALLSTATE = unsafe extern "system" fn(param0: i32, param1: *mut u32) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDBGHELP_CREATE_USER_DUMP_CALLBACK = unsafe extern "system" fn(datatype: u32, data: *const *const ::core::ffi::c_void, datalength: *mut u32, userdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_EXTENSION_CALL = unsafe extern "system" fn(client: ::windows::core::RawPtr, args: super::super::super::Foundation::PSTR) -> ::windows::core::HRESULT;
pub type PDEBUG_EXTENSION_CANUNLOAD = unsafe extern "system" fn() -> ::windows::core::HRESULT;
pub type PDEBUG_EXTENSION_INITIALIZE = unsafe extern "system" fn(version: *mut u32, flags: *mut u32) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_EXTENSION_KNOWN_STRUCT = unsafe extern "system" fn(flags: u32, offset: u64, typename: super::super::super::Foundation::PSTR, buffer: super::super::super::Foundation::PSTR, bufferchars: *mut u32) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_EXTENSION_KNOWN_STRUCT_EX = unsafe extern "system" fn(client: ::windows::core::RawPtr, flags: u32, offset: u64, typename: super::super::super::Foundation::PSTR, buffer: super::super::super::Foundation::PSTR, bufferchars: *mut u32) -> ::windows::core::HRESULT;
pub type PDEBUG_EXTENSION_NOTIFY = unsafe extern "system" fn(notify: u32, argument: u64);
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_EXTENSION_PROVIDE_VALUE = unsafe extern "system" fn(client: ::windows::core::RawPtr, flags: u32, name: super::super::super::Foundation::PWSTR, value: *mut u64, typemodbase: *mut u64, typeid: *mut u32, typeflags: *mut u32) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_EXTENSION_QUERY_VALUE_NAMES = unsafe extern "system" fn(client: ::windows::core::RawPtr, flags: u32, buffer: super::super::super::Foundation::PWSTR, bufferchars: u32, bufferneeded: *mut u32) -> ::windows::core::HRESULT;
pub type PDEBUG_EXTENSION_UNINITIALIZE = unsafe extern "system" fn();
pub type PDEBUG_EXTENSION_UNLOAD = unsafe extern "system" fn();
pub type PDEBUG_STACK_PROVIDER_BEGINTHREADSTACKRECONSTRUCTION = unsafe extern "system" fn(streamtype: u32, minidumpstreambuffer: *const ::core::ffi::c_void, buffersize: u32) -> ::windows::core::HRESULT;
pub type PDEBUG_STACK_PROVIDER_ENDTHREADSTACKRECONSTRUCTION = unsafe extern "system" fn() -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_STACK_PROVIDER_FREESTACKSYMFRAMES = unsafe extern "system" fn(stacksymframes: *const STACK_SYM_FRAME_INFO) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PDEBUG_STACK_PROVIDER_RECONSTRUCTSTACK = unsafe extern "system" fn(systemthreadid: u32, nativeframes: *const DEBUG_STACK_FRAME_EX, countnativeframes: u32, stacksymframes: *mut *mut STACK_SYM_FRAME_INFO, stacksymframesfilled: *mut u32) -> ::windows::core::HRESULT;
#[cfg(feature = "Win32_Foundation")]
pub type PENUMDIRTREE_CALLBACK = unsafe extern "system" fn(filepath: super::super::super::Foundation::PSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PENUMDIRTREE_CALLBACKW = unsafe extern "system" fn(filepath: super::super::super::Foundation::PWSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PENUMLOADED_MODULES_CALLBACK = unsafe extern "system" fn(modulename: super::super::super::Foundation::PSTR, modulebase: u32, modulesize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PENUMLOADED_MODULES_CALLBACK64 = unsafe extern "system" fn(modulename: super::super::super::Foundation::PSTR, modulebase: u64, modulesize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PENUMLOADED_MODULES_CALLBACKW64 = unsafe extern "system" fn(modulename: super::super::super::Foundation::PWSTR, modulebase: u64, modulesize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PENUMSOURCEFILETOKENSCALLBACK = unsafe extern "system" fn(token: *const ::core::ffi::c_void, size: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFINDFILEINPATHCALLBACK = unsafe extern "system" fn(filename: super::super::super::Foundation::PSTR, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFINDFILEINPATHCALLBACKW = unsafe extern "system" fn(filename: super::super::super::Foundation::PWSTR, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFIND_DEBUG_FILE_CALLBACK = unsafe extern "system" fn(filehandle: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFIND_DEBUG_FILE_CALLBACKW = unsafe extern "system" fn(filehandle: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PWSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFIND_EXE_FILE_CALLBACK = unsafe extern "system" fn(filehandle: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PFIND_EXE_FILE_CALLBACKW = unsafe extern "system" fn(filehandle: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PWSTR, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PFUNCTION_TABLE_ACCESS_ROUTINE = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, addrbase: u32) -> *mut ::core::ffi::c_void;
#[cfg(feature = "Win32_Foundation")]
pub type PFUNCTION_TABLE_ACCESS_ROUTINE64 = unsafe extern "system" fn(ahprocess: super::super::super::Foundation::HANDLE, addrbase: u64) -> *mut ::core::ffi::c_void;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PGET_MODULE_BASE_ROUTINE = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, address: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PGET_MODULE_BASE_ROUTINE64 = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, address: u64) -> u64;
#[cfg(any(target_arch = "aarch64",))]
pub type PGET_RUNTIME_FUNCTION_CALLBACK = unsafe extern "system" fn(controlpc: u64, context: *const ::core::ffi::c_void) -> *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;
#[cfg(any(target_arch = "x86_64",))]
pub type PGET_RUNTIME_FUNCTION_CALLBACK = unsafe extern "system" fn(controlpc: u64, context: *const ::core::ffi::c_void) -> *mut IMAGE_RUNTIME_FUNCTION_ENTRY;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL {
pub Address: u64,
pub BufLen: u32,
pub Buf: [u8; 1],
}
impl PHYSICAL {}
impl ::core::default::Default for PHYSICAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL").field("Address", &self.Address).field("BufLen", &self.BufLen).field("Buf", &self.Buf).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.BufLen == other.BufLen && self.Buf == other.Buf
}
}
impl ::core::cmp::Eq for PHYSICAL {}
unsafe impl ::windows::core::Abi for PHYSICAL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_MEMORY_DESCRIPTOR32 {
pub NumberOfRuns: u32,
pub NumberOfPages: u32,
pub Run: [PHYSICAL_MEMORY_RUN32; 1],
}
impl PHYSICAL_MEMORY_DESCRIPTOR32 {}
impl ::core::default::Default for PHYSICAL_MEMORY_DESCRIPTOR32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_MEMORY_DESCRIPTOR32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_MEMORY_DESCRIPTOR32").field("NumberOfRuns", &self.NumberOfRuns).field("NumberOfPages", &self.NumberOfPages).field("Run", &self.Run).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_MEMORY_DESCRIPTOR32 {
fn eq(&self, other: &Self) -> bool {
self.NumberOfRuns == other.NumberOfRuns && self.NumberOfPages == other.NumberOfPages && self.Run == other.Run
}
}
impl ::core::cmp::Eq for PHYSICAL_MEMORY_DESCRIPTOR32 {}
unsafe impl ::windows::core::Abi for PHYSICAL_MEMORY_DESCRIPTOR32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_MEMORY_DESCRIPTOR64 {
pub NumberOfRuns: u32,
pub NumberOfPages: u64,
pub Run: [PHYSICAL_MEMORY_RUN64; 1],
}
impl PHYSICAL_MEMORY_DESCRIPTOR64 {}
impl ::core::default::Default for PHYSICAL_MEMORY_DESCRIPTOR64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_MEMORY_DESCRIPTOR64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_MEMORY_DESCRIPTOR64").field("NumberOfRuns", &self.NumberOfRuns).field("NumberOfPages", &self.NumberOfPages).field("Run", &self.Run).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_MEMORY_DESCRIPTOR64 {
fn eq(&self, other: &Self) -> bool {
self.NumberOfRuns == other.NumberOfRuns && self.NumberOfPages == other.NumberOfPages && self.Run == other.Run
}
}
impl ::core::cmp::Eq for PHYSICAL_MEMORY_DESCRIPTOR64 {}
unsafe impl ::windows::core::Abi for PHYSICAL_MEMORY_DESCRIPTOR64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_MEMORY_RUN32 {
pub BasePage: u32,
pub PageCount: u32,
}
impl PHYSICAL_MEMORY_RUN32 {}
impl ::core::default::Default for PHYSICAL_MEMORY_RUN32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_MEMORY_RUN32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_MEMORY_RUN32").field("BasePage", &self.BasePage).field("PageCount", &self.PageCount).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_MEMORY_RUN32 {
fn eq(&self, other: &Self) -> bool {
self.BasePage == other.BasePage && self.PageCount == other.PageCount
}
}
impl ::core::cmp::Eq for PHYSICAL_MEMORY_RUN32 {}
unsafe impl ::windows::core::Abi for PHYSICAL_MEMORY_RUN32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_MEMORY_RUN64 {
pub BasePage: u64,
pub PageCount: u64,
}
impl PHYSICAL_MEMORY_RUN64 {}
impl ::core::default::Default for PHYSICAL_MEMORY_RUN64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_MEMORY_RUN64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_MEMORY_RUN64").field("BasePage", &self.BasePage).field("PageCount", &self.PageCount).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_MEMORY_RUN64 {
fn eq(&self, other: &Self) -> bool {
self.BasePage == other.BasePage && self.PageCount == other.PageCount
}
}
impl ::core::cmp::Eq for PHYSICAL_MEMORY_RUN64 {}
unsafe impl ::windows::core::Abi for PHYSICAL_MEMORY_RUN64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_TO_VIRTUAL {
pub Status: u32,
pub Size: u32,
pub PdeAddress: u64,
}
impl PHYSICAL_TO_VIRTUAL {}
impl ::core::default::Default for PHYSICAL_TO_VIRTUAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_TO_VIRTUAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_TO_VIRTUAL").field("Status", &self.Status).field("Size", &self.Size).field("PdeAddress", &self.PdeAddress).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_TO_VIRTUAL {
fn eq(&self, other: &Self) -> bool {
self.Status == other.Status && self.Size == other.Size && self.PdeAddress == other.PdeAddress
}
}
impl ::core::cmp::Eq for PHYSICAL_TO_VIRTUAL {}
unsafe impl ::windows::core::Abi for PHYSICAL_TO_VIRTUAL {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PHYSICAL_WITH_FLAGS {
pub Address: u64,
pub BufLen: u32,
pub Flags: u32,
pub Buf: [u8; 1],
}
impl PHYSICAL_WITH_FLAGS {}
impl ::core::default::Default for PHYSICAL_WITH_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PHYSICAL_WITH_FLAGS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PHYSICAL_WITH_FLAGS").field("Address", &self.Address).field("BufLen", &self.BufLen).field("Flags", &self.Flags).field("Buf", &self.Buf).finish()
}
}
impl ::core::cmp::PartialEq for PHYSICAL_WITH_FLAGS {
fn eq(&self, other: &Self) -> bool {
self.Address == other.Address && self.BufLen == other.BufLen && self.Flags == other.Flags && self.Buf == other.Buf
}
}
impl ::core::cmp::Eq for PHYSICAL_WITH_FLAGS {}
unsafe impl ::windows::core::Abi for PHYSICAL_WITH_FLAGS {
type Abi = Self;
}
pub const PHYS_FLAG_CACHED: u32 = 1u32;
pub const PHYS_FLAG_DEFAULT: u32 = 0u32;
pub const PHYS_FLAG_UNCACHED: u32 = 2u32;
pub const PHYS_FLAG_WRITE_COMBINED: u32 = 3u32;
#[cfg(feature = "Win32_Foundation")]
pub type PIMAGEHLP_STATUS_ROUTINE = unsafe extern "system" fn(reason: IMAGEHLP_STATUS_REASON, imagename: super::super::super::Foundation::PSTR, dllname: super::super::super::Foundation::PSTR, va: usize, parameter: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PIMAGEHLP_STATUS_ROUTINE32 = unsafe extern "system" fn(reason: IMAGEHLP_STATUS_REASON, imagename: super::super::super::Foundation::PSTR, dllname: super::super::super::Foundation::PSTR, va: u32, parameter: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PIMAGEHLP_STATUS_ROUTINE64 = unsafe extern "system" fn(reason: IMAGEHLP_STATUS_REASON, imagename: super::super::super::Foundation::PSTR, dllname: super::super::super::Foundation::PSTR, va: u64, parameter: usize) -> super::super::super::Foundation::BOOL;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct POINTER_SEARCH_PHYSICAL {
pub Offset: u64,
pub Length: u64,
pub PointerMin: u64,
pub PointerMax: u64,
pub Flags: u32,
pub MatchOffsets: *mut u64,
pub MatchOffsetsSize: u32,
pub MatchOffsetsCount: u32,
}
impl POINTER_SEARCH_PHYSICAL {}
impl ::core::default::Default for POINTER_SEARCH_PHYSICAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for POINTER_SEARCH_PHYSICAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("POINTER_SEARCH_PHYSICAL")
.field("Offset", &self.Offset)
.field("Length", &self.Length)
.field("PointerMin", &self.PointerMin)
.field("PointerMax", &self.PointerMax)
.field("Flags", &self.Flags)
.field("MatchOffsets", &self.MatchOffsets)
.field("MatchOffsetsSize", &self.MatchOffsetsSize)
.field("MatchOffsetsCount", &self.MatchOffsetsCount)
.finish()
}
}
impl ::core::cmp::PartialEq for POINTER_SEARCH_PHYSICAL {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.Length == other.Length && self.PointerMin == other.PointerMin && self.PointerMax == other.PointerMax && self.Flags == other.Flags && self.MatchOffsets == other.MatchOffsets && self.MatchOffsetsSize == other.MatchOffsetsSize && self.MatchOffsetsCount == other.MatchOffsetsCount
}
}
impl ::core::cmp::Eq for POINTER_SEARCH_PHYSICAL {}
unsafe impl ::windows::core::Abi for POINTER_SEARCH_PHYSICAL {
type Abi = Self;
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PREAD_PROCESS_MEMORY_ROUTINE = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, lpbaseaddress: u32, lpbuffer: *mut ::core::ffi::c_void, nsize: u32, lpnumberofbytesread: *mut u32) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PREAD_PROCESS_MEMORY_ROUTINE64 = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, qwbaseaddress: u64, lpbuffer: *mut ::core::ffi::c_void, nsize: u32, lpnumberofbytesread: *mut u32) -> super::super::super::Foundation::BOOL;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PROCESSORINFO {
pub Processor: u16,
pub NumberProcessors: u16,
}
impl PROCESSORINFO {}
impl ::core::default::Default for PROCESSORINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PROCESSORINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PROCESSORINFO").field("Processor", &self.Processor).field("NumberProcessors", &self.NumberProcessors).finish()
}
}
impl ::core::cmp::PartialEq for PROCESSORINFO {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.NumberProcessors == other.NumberProcessors
}
}
impl ::core::cmp::Eq for PROCESSORINFO {}
unsafe impl ::windows::core::Abi for PROCESSORINFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROCESSOR_ARCHITECTURE(pub u16);
pub const PROCESSOR_ARCHITECTURE_AMD64: PROCESSOR_ARCHITECTURE = PROCESSOR_ARCHITECTURE(9u16);
pub const PROCESSOR_ARCHITECTURE_IA64: PROCESSOR_ARCHITECTURE = PROCESSOR_ARCHITECTURE(6u16);
pub const PROCESSOR_ARCHITECTURE_INTEL: PROCESSOR_ARCHITECTURE = PROCESSOR_ARCHITECTURE(0u16);
pub const PROCESSOR_ARCHITECTURE_ARM: PROCESSOR_ARCHITECTURE = PROCESSOR_ARCHITECTURE(5u16);
pub const PROCESSOR_ARCHITECTURE_UNKNOWN: PROCESSOR_ARCHITECTURE = PROCESSOR_ARCHITECTURE(65535u16);
impl ::core::convert::From<u16> for PROCESSOR_ARCHITECTURE {
fn from(value: u16) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROCESSOR_ARCHITECTURE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PROCESS_NAME_ENTRY {
pub ProcessId: u32,
pub NameOffset: u32,
pub NameSize: u32,
pub NextEntry: u32,
}
impl PROCESS_NAME_ENTRY {}
impl ::core::default::Default for PROCESS_NAME_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PROCESS_NAME_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PROCESS_NAME_ENTRY").field("ProcessId", &self.ProcessId).field("NameOffset", &self.NameOffset).field("NameSize", &self.NameSize).field("NextEntry", &self.NextEntry).finish()
}
}
impl ::core::cmp::PartialEq for PROCESS_NAME_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.ProcessId == other.ProcessId && self.NameOffset == other.NameOffset && self.NameSize == other.NameSize && self.NextEntry == other.NextEntry
}
}
impl ::core::cmp::Eq for PROCESS_NAME_ENTRY {}
unsafe impl ::windows::core::Abi for PROCESS_NAME_ENTRY {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_EVENT_MASK(pub u32);
pub const PROFILER_EVENT_MASK_TRACE_SCRIPT_FUNCTION_CALL: PROFILER_EVENT_MASK = PROFILER_EVENT_MASK(1u32);
pub const PROFILER_EVENT_MASK_TRACE_NATIVE_FUNCTION_CALL: PROFILER_EVENT_MASK = PROFILER_EVENT_MASK(2u32);
pub const PROFILER_EVENT_MASK_TRACE_DOM_FUNCTION_CALL: PROFILER_EVENT_MASK = PROFILER_EVENT_MASK(4u32);
pub const PROFILER_EVENT_MASK_TRACE_ALL: PROFILER_EVENT_MASK = PROFILER_EVENT_MASK(3u32);
pub const PROFILER_EVENT_MASK_TRACE_ALL_WITH_DOM: PROFILER_EVENT_MASK = PROFILER_EVENT_MASK(7u32);
impl ::core::convert::From<u32> for PROFILER_EVENT_MASK {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_EVENT_MASK {
type Abi = Self;
}
impl ::core::ops::BitOr for PROFILER_EVENT_MASK {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for PROFILER_EVENT_MASK {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for PROFILER_EVENT_MASK {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for PROFILER_EVENT_MASK {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for PROFILER_EVENT_MASK {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_HEAP_ENUM_FLAGS(pub u32);
pub const PROFILER_HEAP_ENUM_FLAGS_NONE: PROFILER_HEAP_ENUM_FLAGS = PROFILER_HEAP_ENUM_FLAGS(0u32);
pub const PROFILER_HEAP_ENUM_FLAGS_STORE_RELATIONSHIP_FLAGS: PROFILER_HEAP_ENUM_FLAGS = PROFILER_HEAP_ENUM_FLAGS(1u32);
pub const PROFILER_HEAP_ENUM_FLAGS_SUBSTRINGS: PROFILER_HEAP_ENUM_FLAGS = PROFILER_HEAP_ENUM_FLAGS(2u32);
pub const PROFILER_HEAP_ENUM_FLAGS_RELATIONSHIP_SUBSTRINGS: PROFILER_HEAP_ENUM_FLAGS = PROFILER_HEAP_ENUM_FLAGS(3u32);
impl ::core::convert::From<u32> for PROFILER_HEAP_ENUM_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_ENUM_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for PROFILER_HEAP_ENUM_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for PROFILER_HEAP_ENUM_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for PROFILER_HEAP_ENUM_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for PROFILER_HEAP_ENUM_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for PROFILER_HEAP_ENUM_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PROFILER_HEAP_OBJECT {
pub size: u32,
pub Anonymous: PROFILER_HEAP_OBJECT_0,
pub typeNameId: u32,
pub flags: u32,
pub unused: u16,
pub optionalInfoCount: u16,
}
impl PROFILER_HEAP_OBJECT {}
impl ::core::default::Default for PROFILER_HEAP_OBJECT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT {}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union PROFILER_HEAP_OBJECT_0 {
pub objectId: usize,
pub externalObjectAddress: *mut ::core::ffi::c_void,
}
impl PROFILER_HEAP_OBJECT_0 {}
impl ::core::default::Default for PROFILER_HEAP_OBJECT_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_0 {}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_HEAP_OBJECT_FLAGS(pub u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_NEW_OBJECT: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(1u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_IS_ROOT: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(2u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_SITE_CLOSED: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(4u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_EXTERNAL: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(8u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_EXTERNAL_UNKNOWN: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(16u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_EXTERNAL_DISPATCH: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(32u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_SIZE_APPROXIMATE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(64u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_SIZE_UNAVAILABLE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(128u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_NEW_STATE_UNAVAILABLE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(256u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_WINRT_INSTANCE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(512u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_WINRT_RUNTIMECLASS: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(1024u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_WINRT_DELEGATE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(2048u32);
pub const PROFILER_HEAP_OBJECT_FLAGS_WINRT_NAMESPACE: PROFILER_HEAP_OBJECT_FLAGS = PROFILER_HEAP_OBJECT_FLAGS(4096u32);
impl ::core::convert::From<u32> for PROFILER_HEAP_OBJECT_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for PROFILER_HEAP_OBJECT_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for PROFILER_HEAP_OBJECT_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for PROFILER_HEAP_OBJECT_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for PROFILER_HEAP_OBJECT_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for PROFILER_HEAP_OBJECT_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const PROFILER_HEAP_OBJECT_NAME_ID_UNAVAILABLE: u32 = 4294967295u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROFILER_HEAP_OBJECT_OPTIONAL_INFO {
pub infoType: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE,
pub Anonymous: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0,
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_HEAP_OBJECT_OPTIONAL_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_HEAP_OBJECT_OPTIONAL_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_OPTIONAL_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_OPTIONAL_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_OPTIONAL_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {
pub prototype: usize,
pub functionName: super::super::super::Foundation::PWSTR,
pub elementAttributesSize: u32,
pub elementTextChildrenSize: u32,
pub scopeList: *mut PROFILER_HEAP_OBJECT_SCOPE_LIST,
pub internalProperty: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP>,
pub namePropertyList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub indexPropertyList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub relationshipList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub eventList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub weakMapCollectionList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub mapCollectionList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
pub setCollectionList: *mut ::core::mem::ManuallyDrop<PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST>,
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(pub i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_PROTOTYPE: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(1i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_FUNCTION_NAME: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(2i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_SCOPE_LIST: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(3i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_INTERNAL_PROPERTY: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(4i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_NAME_PROPERTIES: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(5i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_INDEX_PROPERTIES: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(6i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_ELEMENT_ATTRIBUTES_SIZE: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(7i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_ELEMENT_TEXT_CHILDREN_SIZE: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(8i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_RELATIONSHIPS: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(9i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_WINRTEVENTS: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(10i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_WEAKMAP_COLLECTION_LIST: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(11i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_MAP_COLLECTION_LIST: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(12i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_SET_COLLECTION_LIST: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(13i32);
pub const PROFILER_HEAP_OBJECT_OPTIONAL_INFO_MAX_VALUE: PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE = PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE(13i32);
impl ::core::convert::From<i32> for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_OPTIONAL_INFO_TYPE {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROFILER_HEAP_OBJECT_RELATIONSHIP {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROFILER_HEAP_OBJECT_RELATIONSHIP {
pub relationshipId: u32,
pub relationshipInfo: PROFILER_RELATIONSHIP_INFO,
pub Anonymous: PROFILER_HEAP_OBJECT_RELATIONSHIP_0,
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_HEAP_OBJECT_RELATIONSHIP {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_HEAP_OBJECT_RELATIONSHIP {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_RELATIONSHIP {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_RELATIONSHIP {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_RELATIONSHIP {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {
pub numberValue: f64,
pub stringValue: super::super::super::Foundation::PWSTR,
pub bstrValue: ::core::mem::ManuallyDrop<super::super::super::Foundation::BSTR>,
pub objectId: usize,
pub externalObjectAddress: *mut ::core::ffi::c_void,
pub subString: *mut PROFILER_PROPERTY_TYPE_SUBSTRING_INFO,
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_RELATIONSHIP_0 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(pub u32);
pub const PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS_NONE: PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS = PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(0u32);
pub const PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS_IS_GET_ACCESSOR: PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS = PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(65536u32);
pub const PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS_IS_SET_ACCESSOR: PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS = PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(131072u32);
pub const PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS_LET_VARIABLE: PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS = PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(262144u32);
pub const PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS_CONST_VARIABLE: PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS = PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS(524288u32);
impl ::core::convert::From<u32> for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for PROFILER_HEAP_OBJECT_RELATIONSHIP_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {
pub count: u32,
pub elements: [PROFILER_HEAP_OBJECT_RELATIONSHIP; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_RELATIONSHIP_LIST {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PROFILER_HEAP_OBJECT_SCOPE_LIST {
pub count: u32,
pub scopes: [usize; 1],
}
impl PROFILER_HEAP_OBJECT_SCOPE_LIST {}
impl ::core::default::Default for PROFILER_HEAP_OBJECT_SCOPE_LIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PROFILER_HEAP_OBJECT_SCOPE_LIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PROFILER_HEAP_OBJECT_SCOPE_LIST").field("count", &self.count).field("scopes", &self.scopes).finish()
}
}
impl ::core::cmp::PartialEq for PROFILER_HEAP_OBJECT_SCOPE_LIST {
fn eq(&self, other: &Self) -> bool {
self.count == other.count && self.scopes == other.scopes
}
}
impl ::core::cmp::Eq for PROFILER_HEAP_OBJECT_SCOPE_LIST {}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_OBJECT_SCOPE_LIST {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct PROFILER_HEAP_SUMMARY {
pub version: PROFILER_HEAP_SUMMARY_VERSION,
pub totalHeapSize: u32,
}
impl PROFILER_HEAP_SUMMARY {}
impl ::core::default::Default for PROFILER_HEAP_SUMMARY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for PROFILER_HEAP_SUMMARY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PROFILER_HEAP_SUMMARY").field("version", &self.version).field("totalHeapSize", &self.totalHeapSize).finish()
}
}
impl ::core::cmp::PartialEq for PROFILER_HEAP_SUMMARY {
fn eq(&self, other: &Self) -> bool {
self.version == other.version && self.totalHeapSize == other.totalHeapSize
}
}
impl ::core::cmp::Eq for PROFILER_HEAP_SUMMARY {}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_SUMMARY {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_HEAP_SUMMARY_VERSION(pub i32);
pub const PROFILER_HEAP_SUMMARY_VERSION_1: PROFILER_HEAP_SUMMARY_VERSION = PROFILER_HEAP_SUMMARY_VERSION(1i32);
impl ::core::convert::From<i32> for PROFILER_HEAP_SUMMARY_VERSION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_HEAP_SUMMARY_VERSION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {
pub length: u32,
pub value: super::super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("PROFILER_PROPERTY_TYPE_SUBSTRING_INFO").field("length", &self.length).field("value", &self.value).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {
fn eq(&self, other: &Self) -> bool {
self.length == other.length && self.value == other.value
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for PROFILER_PROPERTY_TYPE_SUBSTRING_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_RELATIONSHIP_INFO(pub i32);
pub const PROFILER_PROPERTY_TYPE_NUMBER: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(1i32);
pub const PROFILER_PROPERTY_TYPE_STRING: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(2i32);
pub const PROFILER_PROPERTY_TYPE_HEAP_OBJECT: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(3i32);
pub const PROFILER_PROPERTY_TYPE_EXTERNAL_OBJECT: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(4i32);
pub const PROFILER_PROPERTY_TYPE_BSTR: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(5i32);
pub const PROFILER_PROPERTY_TYPE_SUBSTRING: PROFILER_RELATIONSHIP_INFO = PROFILER_RELATIONSHIP_INFO(6i32);
impl ::core::convert::From<i32> for PROFILER_RELATIONSHIP_INFO {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_RELATIONSHIP_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROFILER_SCRIPT_TYPE(pub i32);
pub const PROFILER_SCRIPT_TYPE_USER: PROFILER_SCRIPT_TYPE = PROFILER_SCRIPT_TYPE(0i32);
pub const PROFILER_SCRIPT_TYPE_DYNAMIC: PROFILER_SCRIPT_TYPE = PROFILER_SCRIPT_TYPE(1i32);
pub const PROFILER_SCRIPT_TYPE_NATIVE: PROFILER_SCRIPT_TYPE = PROFILER_SCRIPT_TYPE(2i32);
pub const PROFILER_SCRIPT_TYPE_DOM: PROFILER_SCRIPT_TYPE = PROFILER_SCRIPT_TYPE(3i32);
impl ::core::convert::From<i32> for PROFILER_SCRIPT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROFILER_SCRIPT_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PROP_INFO_FLAGS(pub i32);
pub const PROP_INFO_NAME: PROP_INFO_FLAGS = PROP_INFO_FLAGS(1i32);
pub const PROP_INFO_TYPE: PROP_INFO_FLAGS = PROP_INFO_FLAGS(2i32);
pub const PROP_INFO_VALUE: PROP_INFO_FLAGS = PROP_INFO_FLAGS(4i32);
pub const PROP_INFO_FULLNAME: PROP_INFO_FLAGS = PROP_INFO_FLAGS(32i32);
pub const PROP_INFO_ATTRIBUTES: PROP_INFO_FLAGS = PROP_INFO_FLAGS(8i32);
pub const PROP_INFO_DEBUGPROP: PROP_INFO_FLAGS = PROP_INFO_FLAGS(16i32);
pub const PROP_INFO_AUTOEXPAND: PROP_INFO_FLAGS = PROP_INFO_FLAGS(134217728i32);
impl ::core::convert::From<i32> for PROP_INFO_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PROP_INFO_FLAGS {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERBYINDEXPROC = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: super::super::super::Foundation::PSTR, param3: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERBYINDEXPROCA = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: super::super::super::Foundation::PSTR, param3: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERBYINDEXPROCW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: super::super::super::Foundation::PWSTR, param3: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERCALLBACKPROC = unsafe extern "system" fn(action: usize, data: u64, context: u64) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERCLOSEPROC = unsafe extern "system" fn() -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERDELTANAME = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: *mut ::core::ffi::c_void, param2: u32, param3: u32, param4: *mut ::core::ffi::c_void, param5: u32, param6: u32, param7: super::super::super::Foundation::PSTR, param8: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERDELTANAMEW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: *mut ::core::ffi::c_void, param2: u32, param3: u32, param4: *mut ::core::ffi::c_void, param5: u32, param6: u32, param7: super::super::super::Foundation::PWSTR, param8: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETINDEXSTRING = unsafe extern "system" fn(param0: *mut ::core::ffi::c_void, param1: u32, param2: u32, param3: super::super::super::Foundation::PSTR, param4: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETINDEXSTRINGW = unsafe extern "system" fn(param0: *mut ::core::ffi::c_void, param1: u32, param2: u32, param3: super::super::super::Foundation::PWSTR, param4: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETOPTIONDATAPROC = unsafe extern "system" fn(param0: usize, param1: *mut u64) -> super::super::super::Foundation::BOOL;
pub type PSYMBOLSERVERGETOPTIONSPROC = unsafe extern "system" fn() -> usize;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETSUPPLEMENT = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: super::super::super::Foundation::PSTR, param3: super::super::super::Foundation::PSTR, param4: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETSUPPLEMENTW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: super::super::super::Foundation::PWSTR, param3: super::super::super::Foundation::PWSTR, param4: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERGETVERSION = unsafe extern "system" fn(param0: *mut API_VERSION) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERISSTORE = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERISSTOREW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERMESSAGEPROC = unsafe extern "system" fn(action: usize, data: u64, context: u64) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVEROPENPROC = unsafe extern "system" fn() -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPINGPROC = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPINGPROCA = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPINGPROCW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPINGPROCWEX = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPROC = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPROCA = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERPROCW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSETHTTPAUTHHEADER = unsafe extern "system" fn(pszauthheader: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSETOPTIONSPROC = unsafe extern "system" fn(param0: usize, param1: u64) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSETOPTIONSWPROC = unsafe extern "system" fn(param0: usize, param1: u64) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSTOREFILE = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PSTR, param6: usize, param7: u32) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSTOREFILEW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PWSTR, param6: usize, param7: u32) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSTORESUPPLEMENT = unsafe extern "system" fn(param0: super::super::super::Foundation::PSTR, param1: super::super::super::Foundation::PSTR, param2: super::super::super::Foundation::PSTR, param3: super::super::super::Foundation::PSTR, param4: usize, param5: u32) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERSTORESUPPLEMENTW = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: super::super::super::Foundation::PWSTR, param3: super::super::super::Foundation::PWSTR, param4: usize, param5: u32) -> super::super::super::Foundation::BOOL;
pub type PSYMBOLSERVERVERSION = unsafe extern "system" fn() -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOLSERVERWEXPROC = unsafe extern "system" fn(param0: super::super::super::Foundation::PWSTR, param1: super::super::super::Foundation::PWSTR, param2: *mut ::core::ffi::c_void, param3: u32, param4: u32, param5: super::super::super::Foundation::PWSTR, param6: *mut SYMSRV_EXTENDED_OUTPUT_DATA) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOL_FUNCENTRY_CALLBACK = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, addrbase: u32, usercontext: *const ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOL_FUNCENTRY_CALLBACK64 = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, addrbase: u64, usercontext: u64) -> *mut ::core::ffi::c_void;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOL_REGISTERED_CALLBACK = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, actioncode: u32, callbackdata: *const ::core::ffi::c_void, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYMBOL_REGISTERED_CALLBACK64 = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, actioncode: u32, callbackdata: u64, usercontext: u64) -> super::super::super::Foundation::BOOL;
pub type PSYM_DUMP_FIELD_CALLBACK = unsafe extern "system" fn(pfield: *mut FIELD_INFO, usercontext: *mut ::core::ffi::c_void) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMERATESYMBOLS_CALLBACK = unsafe extern "system" fn(psyminfo: *const SYMBOL_INFO, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMERATESYMBOLS_CALLBACKW = unsafe extern "system" fn(psyminfo: *const SYMBOL_INFOW, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMLINES_CALLBACK = unsafe extern "system" fn(lineinfo: *const SRCCODEINFO, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMLINES_CALLBACKW = unsafe extern "system" fn(lineinfo: *const SRCCODEINFOW, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMMODULES_CALLBACK = unsafe extern "system" fn(modulename: super::super::super::Foundation::PSTR, baseofdll: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMMODULES_CALLBACK64 = unsafe extern "system" fn(modulename: super::super::super::Foundation::PSTR, baseofdll: u64, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMMODULES_CALLBACKW64 = unsafe extern "system" fn(modulename: super::super::super::Foundation::PWSTR, baseofdll: u64, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMPROCESSES_CALLBACK = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSOURCEFILES_CALLBACK = unsafe extern "system" fn(psourcefile: *const SOURCEFILE, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSOURCEFILES_CALLBACKW = unsafe extern "system" fn(psourcefile: *const SOURCEFILEW, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSYMBOLS_CALLBACK = unsafe extern "system" fn(symbolname: super::super::super::Foundation::PSTR, symboladdress: u32, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSYMBOLS_CALLBACK64 = unsafe extern "system" fn(symbolname: super::super::super::Foundation::PSTR, symboladdress: u64, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSYMBOLS_CALLBACK64W = unsafe extern "system" fn(symbolname: super::super::super::Foundation::PWSTR, symboladdress: u64, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PSYM_ENUMSYMBOLS_CALLBACKW = unsafe extern "system" fn(symbolname: super::super::super::Foundation::PWSTR, symboladdress: u32, symbolsize: u32, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub type PTRANSLATE_ADDRESS_ROUTINE = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, hthread: super::super::super::Foundation::HANDLE, lpaddr: *mut ADDRESS) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PTRANSLATE_ADDRESS_ROUTINE64 = unsafe extern "system" fn(hprocess: super::super::super::Foundation::HANDLE, hthread: super::super::super::Foundation::HANDLE, lpaddr: *const ADDRESS64) -> u64;
pub const PTR_SEARCH_NO_SYMBOL_CHECK: u32 = 2147483648u32;
pub const PTR_SEARCH_PHYS_ALL_HITS: u32 = 1u32;
pub const PTR_SEARCH_PHYS_PTE: u32 = 2u32;
pub const PTR_SEARCH_PHYS_RANGE_CHECK_ONLY: u32 = 4u32;
pub const PTR_SEARCH_PHYS_SIZE_SHIFT: u32 = 3u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type PVECTORED_EXCEPTION_HANDLER = unsafe extern "system" fn(exceptioninfo: *mut EXCEPTION_POINTERS) -> i32;
#[cfg(feature = "Win32_Foundation")]
pub type PWAITCHAINCALLBACK = unsafe extern "system" fn(wcthandle: *mut ::core::ffi::c_void, context: usize, callbackstatus: u32, nodecount: *mut u32, nodeinfoarray: *mut WAITCHAIN_NODE_INFO, iscycle: *mut i32);
pub type PWINDBG_CHECK_CONTROL_C = unsafe extern "system" fn() -> u32;
pub type PWINDBG_CHECK_VERSION = unsafe extern "system" fn() -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_DISASM = unsafe extern "system" fn(lpoffset: *mut usize, lpbuffer: super::super::super::Foundation::PSTR, fshoweffectiveaddress: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_DISASM32 = unsafe extern "system" fn(lpoffset: *mut u32, lpbuffer: super::super::super::Foundation::PSTR, fshoweffectiveaddress: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_DISASM64 = unsafe extern "system" fn(lpoffset: *mut u64, lpbuffer: super::super::super::Foundation::PSTR, fshoweffectiveaddress: u32) -> u32;
pub type PWINDBG_EXTENSION_API_VERSION = unsafe extern "system" fn() -> *mut EXT_API_VERSION;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type PWINDBG_EXTENSION_DLL_INIT = unsafe extern "system" fn(lpextensionapis: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS>, majorversion: u16, minorversion: u16);
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type PWINDBG_EXTENSION_DLL_INIT32 = unsafe extern "system" fn(lpextensionapis: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS32>, majorversion: u16, minorversion: u16);
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type PWINDBG_EXTENSION_DLL_INIT64 = unsafe extern "system" fn(lpextensionapis: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS64>, majorversion: u16, minorversion: u16);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_EXTENSION_ROUTINE = unsafe extern "system" fn(hcurrentprocess: super::super::super::Foundation::HANDLE, hcurrentthread: super::super::super::Foundation::HANDLE, dwcurrentpc: u32, dwprocessor: u32, lpargumentstring: super::super::super::Foundation::PSTR);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_EXTENSION_ROUTINE32 = unsafe extern "system" fn(hcurrentprocess: super::super::super::Foundation::HANDLE, hcurrentthread: super::super::super::Foundation::HANDLE, dwcurrentpc: u32, dwprocessor: u32, lpargumentstring: super::super::super::Foundation::PSTR);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_EXTENSION_ROUTINE64 = unsafe extern "system" fn(hcurrentprocess: super::super::super::Foundation::HANDLE, hcurrentthread: super::super::super::Foundation::HANDLE, dwcurrentpc: u64, dwprocessor: u32, lpargumentstring: super::super::super::Foundation::PSTR);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_EXPRESSION = unsafe extern "system" fn(lpexpression: super::super::super::Foundation::PSTR) -> usize;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_EXPRESSION32 = unsafe extern "system" fn(lpexpression: super::super::super::Foundation::PSTR) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_EXPRESSION64 = unsafe extern "system" fn(lpexpression: super::super::super::Foundation::PSTR) -> u64;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_SYMBOL = unsafe extern "system" fn(offset: *mut ::core::ffi::c_void, pchbuffer: super::super::super::Foundation::PSTR, pdisplacement: *mut usize);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_SYMBOL32 = unsafe extern "system" fn(offset: u32, pchbuffer: super::super::super::Foundation::PSTR, pdisplacement: *mut u32);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_GET_SYMBOL64 = unsafe extern "system" fn(offset: u64, pchbuffer: super::super::super::Foundation::PSTR, pdisplacement: *mut u64);
#[cfg(feature = "Win32_System_Kernel")]
pub type PWINDBG_GET_THREAD_CONTEXT_ROUTINE = unsafe extern "system" fn(processor: u32, lpcontext: *mut CONTEXT, cbsizeofcontext: u32) -> u32;
pub type PWINDBG_IOCTL_ROUTINE = unsafe extern "system" fn(ioctltype: u16, lpvdata: *mut ::core::ffi::c_void, cbsize: u32) -> u32;
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_OLDKD_EXTENSION_ROUTINE = unsafe extern "system" fn(dwcurrentpc: u32, lpextensionapis: *mut ::core::mem::ManuallyDrop<WINDBG_OLDKD_EXTENSION_APIS>, lpargumentstring: super::super::super::Foundation::PSTR);
pub type PWINDBG_OLDKD_READ_PHYSICAL_MEMORY = unsafe extern "system" fn(address: u64, buffer: *mut ::core::ffi::c_void, count: u32, bytesread: *mut u32) -> u32;
pub type PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY = unsafe extern "system" fn(address: u64, buffer: *mut ::core::ffi::c_void, length: u32, byteswritten: *mut u32) -> u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub type PWINDBG_OLD_EXTENSION_ROUTINE = unsafe extern "system" fn(dwcurrentpc: u32, lpextensionapis: *mut ::core::mem::ManuallyDrop<WINDBG_EXTENSION_APIS>, lpargumentstring: super::super::super::Foundation::PSTR);
#[cfg(feature = "Win32_Foundation")]
pub type PWINDBG_OUTPUT_ROUTINE = unsafe extern "system" fn(lpformat: super::super::super::Foundation::PSTR);
pub type PWINDBG_READ_PROCESS_MEMORY_ROUTINE = unsafe extern "system" fn(offset: usize, lpbuffer: *mut ::core::ffi::c_void, cb: u32, lpcbbytesread: *mut u32) -> u32;
pub type PWINDBG_READ_PROCESS_MEMORY_ROUTINE32 = unsafe extern "system" fn(offset: u32, lpbuffer: *mut ::core::ffi::c_void, cb: u32, lpcbbytesread: *mut u32) -> u32;
pub type PWINDBG_READ_PROCESS_MEMORY_ROUTINE64 = unsafe extern "system" fn(offset: u64, lpbuffer: *mut ::core::ffi::c_void, cb: u32, lpcbbytesread: *mut u32) -> u32;
#[cfg(feature = "Win32_System_Kernel")]
pub type PWINDBG_SET_THREAD_CONTEXT_ROUTINE = unsafe extern "system" fn(processor: u32, lpcontext: *mut CONTEXT, cbsizeofcontext: u32) -> u32;
pub type PWINDBG_STACKTRACE_ROUTINE = unsafe extern "system" fn(framepointer: u32, stackpointer: u32, programcounter: u32, stackframes: *mut EXTSTACKTRACE, frames: u32) -> u32;
pub type PWINDBG_STACKTRACE_ROUTINE32 = unsafe extern "system" fn(framepointer: u32, stackpointer: u32, programcounter: u32, stackframes: *mut EXTSTACKTRACE32, frames: u32) -> u32;
pub type PWINDBG_STACKTRACE_ROUTINE64 = unsafe extern "system" fn(framepointer: u64, stackpointer: u64, programcounter: u64, stackframes: *mut EXTSTACKTRACE64, frames: u32) -> u32;
pub type PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE = unsafe extern "system" fn(offset: usize, lpbuffer: *const ::core::ffi::c_void, cb: u32, lpcbbyteswritten: *mut u32) -> u32;
pub type PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32 = unsafe extern "system" fn(offset: u32, lpbuffer: *const ::core::ffi::c_void, cb: u32, lpcbbyteswritten: *mut u32) -> u32;
pub type PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE64 = unsafe extern "system" fn(offset: u64, lpbuffer: *const ::core::ffi::c_void, cb: u32, lpcbbyteswritten: *mut u32) -> u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PointerKind(pub i32);
pub const PointerStandard: PointerKind = PointerKind(0i32);
pub const PointerReference: PointerKind = PointerKind(1i32);
pub const PointerRValueReference: PointerKind = PointerKind(2i32);
pub const PointerCXHat: PointerKind = PointerKind(3i32);
pub const PointerManagedReference: PointerKind = PointerKind(4i32);
impl ::core::convert::From<i32> for PointerKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PointerKind {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PreferredFormat(pub i32);
pub const FormatNone: PreferredFormat = PreferredFormat(0i32);
pub const FormatSingleCharacter: PreferredFormat = PreferredFormat(1i32);
pub const FormatQuotedString: PreferredFormat = PreferredFormat(2i32);
pub const FormatString: PreferredFormat = PreferredFormat(3i32);
pub const FormatQuotedUnicodeString: PreferredFormat = PreferredFormat(4i32);
pub const FormatUnicodeString: PreferredFormat = PreferredFormat(5i32);
pub const FormatQuotedUTF8String: PreferredFormat = PreferredFormat(6i32);
pub const FormatUTF8String: PreferredFormat = PreferredFormat(7i32);
pub const FormatBSTRString: PreferredFormat = PreferredFormat(8i32);
pub const FormatQuotedHString: PreferredFormat = PreferredFormat(9i32);
pub const FormatHString: PreferredFormat = PreferredFormat(10i32);
pub const FormatRaw: PreferredFormat = PreferredFormat(11i32);
pub const FormatEnumNameOnly: PreferredFormat = PreferredFormat(12i32);
pub const FormatEscapedStringWithQuote: PreferredFormat = PreferredFormat(13i32);
pub const FormatUTF32String: PreferredFormat = PreferredFormat(14i32);
pub const FormatQuotedUTF32String: PreferredFormat = PreferredFormat(15i32);
impl ::core::convert::From<i32> for PreferredFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PreferredFormat {
type Abi = Self;
}
pub const ProcessDebugManager: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x78a51822_51f4_11d0_8f20_00805f2cd064);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct READCONTROLSPACE {
pub Processor: u16,
pub Address: u32,
pub BufLen: u32,
pub Buf: [u8; 1],
}
impl READCONTROLSPACE {}
impl ::core::default::Default for READCONTROLSPACE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for READCONTROLSPACE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("READCONTROLSPACE").field("Processor", &self.Processor).field("Address", &self.Address).field("BufLen", &self.BufLen).field("Buf", &self.Buf).finish()
}
}
impl ::core::cmp::PartialEq for READCONTROLSPACE {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.Address == other.Address && self.BufLen == other.BufLen && self.Buf == other.Buf
}
}
impl ::core::cmp::Eq for READCONTROLSPACE {}
unsafe impl ::windows::core::Abi for READCONTROLSPACE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct READCONTROLSPACE32 {
pub Processor: u16,
pub Address: u32,
pub BufLen: u32,
pub Buf: [u8; 1],
}
impl READCONTROLSPACE32 {}
impl ::core::default::Default for READCONTROLSPACE32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for READCONTROLSPACE32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("READCONTROLSPACE32").field("Processor", &self.Processor).field("Address", &self.Address).field("BufLen", &self.BufLen).field("Buf", &self.Buf).finish()
}
}
impl ::core::cmp::PartialEq for READCONTROLSPACE32 {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.Address == other.Address && self.BufLen == other.BufLen && self.Buf == other.Buf
}
}
impl ::core::cmp::Eq for READCONTROLSPACE32 {}
unsafe impl ::windows::core::Abi for READCONTROLSPACE32 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct READCONTROLSPACE64 {
pub Processor: u16,
pub Address: u64,
pub BufLen: u32,
pub Buf: [u8; 1],
}
impl READCONTROLSPACE64 {}
impl ::core::default::Default for READCONTROLSPACE64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for READCONTROLSPACE64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("READCONTROLSPACE64").field("Processor", &self.Processor).field("Address", &self.Address).field("BufLen", &self.BufLen).field("Buf", &self.Buf).finish()
}
}
impl ::core::cmp::PartialEq for READCONTROLSPACE64 {
fn eq(&self, other: &Self) -> bool {
self.Processor == other.Processor && self.Address == other.Address && self.BufLen == other.BufLen && self.Buf == other.Buf
}
}
impl ::core::cmp::Eq for READCONTROLSPACE64 {}
unsafe impl ::windows::core::Abi for READCONTROLSPACE64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct READ_WRITE_MSR {
pub Msr: u32,
pub Value: i64,
}
impl READ_WRITE_MSR {}
impl ::core::default::Default for READ_WRITE_MSR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for READ_WRITE_MSR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("READ_WRITE_MSR").field("Msr", &self.Msr).field("Value", &self.Value).finish()
}
}
impl ::core::cmp::PartialEq for READ_WRITE_MSR {
fn eq(&self, other: &Self) -> bool {
self.Msr == other.Msr && self.Value == other.Value
}
}
impl ::core::cmp::Eq for READ_WRITE_MSR {}
unsafe impl ::windows::core::Abi for READ_WRITE_MSR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct RIP_INFO {
pub dwError: u32,
pub dwType: RIP_INFO_TYPE,
}
impl RIP_INFO {}
impl ::core::default::Default for RIP_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for RIP_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("RIP_INFO").field("dwError", &self.dwError).field("dwType", &self.dwType).finish()
}
}
impl ::core::cmp::PartialEq for RIP_INFO {
fn eq(&self, other: &Self) -> bool {
self.dwError == other.dwError && self.dwType == other.dwType
}
}
impl ::core::cmp::Eq for RIP_INFO {}
unsafe impl ::windows::core::Abi for RIP_INFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct RIP_INFO_TYPE(pub u32);
pub const SLE_ERROR: RIP_INFO_TYPE = RIP_INFO_TYPE(1u32);
pub const SLE_MINORERROR: RIP_INFO_TYPE = RIP_INFO_TYPE(2u32);
pub const SLE_WARNING: RIP_INFO_TYPE = RIP_INFO_TYPE(3u32);
impl ::core::convert::From<u32> for RIP_INFO_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for RIP_INFO_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for RIP_INFO_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for RIP_INFO_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for RIP_INFO_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for RIP_INFO_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for RIP_INFO_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct RTL_VIRTUAL_UNWIND_HANDLER_TYPE(pub u32);
pub const UNW_FLAG_NHANDLER: RTL_VIRTUAL_UNWIND_HANDLER_TYPE = RTL_VIRTUAL_UNWIND_HANDLER_TYPE(0u32);
pub const UNW_FLAG_EHANDLER: RTL_VIRTUAL_UNWIND_HANDLER_TYPE = RTL_VIRTUAL_UNWIND_HANDLER_TYPE(1u32);
pub const UNW_FLAG_UHANDLER: RTL_VIRTUAL_UNWIND_HANDLER_TYPE = RTL_VIRTUAL_UNWIND_HANDLER_TYPE(2u32);
pub const UNW_FLAG_CHAININFO: RTL_VIRTUAL_UNWIND_HANDLER_TYPE = RTL_VIRTUAL_UNWIND_HANDLER_TYPE(4u32);
impl ::core::convert::From<u32> for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
type Abi = Self;
}
impl ::core::ops::BitOr for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for RTL_VIRTUAL_UNWIND_HANDLER_TYPE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[inline]
pub unsafe fn RaiseException(dwexceptioncode: u32, dwexceptionflags: u32, nnumberofarguments: u32, lparguments: *const usize) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RaiseException(dwexceptioncode: u32, dwexceptionflags: u32, nnumberofarguments: u32, lparguments: *const usize);
}
::core::mem::transmute(RaiseException(::core::mem::transmute(dwexceptioncode), ::core::mem::transmute(dwexceptionflags), ::core::mem::transmute(nnumberofarguments), ::core::mem::transmute(lparguments)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn RaiseFailFastException(pexceptionrecord: *const EXCEPTION_RECORD, pcontextrecord: *const CONTEXT, dwflags: u32) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RaiseFailFastException(pexceptionrecord: *const EXCEPTION_RECORD, pcontextrecord: *const CONTEXT, dwflags: u32);
}
::core::mem::transmute(RaiseFailFastException(::core::mem::transmute(pexceptionrecord), ::core::mem::transmute(pcontextrecord), ::core::mem::transmute(dwflags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RangeMapAddPeImageSections<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(rmaphandle: *const ::core::ffi::c_void, imagename: Param1, mappedimage: *const ::core::ffi::c_void, mappingbytes: u32, imagebase: u64, usertag: u64, mappingflags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapAddPeImageSections(rmaphandle: *const ::core::ffi::c_void, imagename: super::super::super::Foundation::PWSTR, mappedimage: *const ::core::ffi::c_void, mappingbytes: u32, imagebase: u64, usertag: u64, mappingflags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(RangeMapAddPeImageSections(::core::mem::transmute(rmaphandle), imagename.into_param().abi(), ::core::mem::transmute(mappedimage), ::core::mem::transmute(mappingbytes), ::core::mem::transmute(imagebase), ::core::mem::transmute(usertag), ::core::mem::transmute(mappingflags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RangeMapCreate() -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapCreate() -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(RangeMapCreate())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RangeMapFree(rmaphandle: *const ::core::ffi::c_void) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapFree(rmaphandle: *const ::core::ffi::c_void);
}
::core::mem::transmute(RangeMapFree(::core::mem::transmute(rmaphandle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RangeMapRead(rmaphandle: *const ::core::ffi::c_void, offset: u64, buffer: *mut ::core::ffi::c_void, requestbytes: u32, flags: u32, donebytes: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapRead(rmaphandle: *const ::core::ffi::c_void, offset: u64, buffer: *mut ::core::ffi::c_void, requestbytes: u32, flags: u32, donebytes: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(RangeMapRead(::core::mem::transmute(rmaphandle), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(requestbytes), ::core::mem::transmute(flags), ::core::mem::transmute(donebytes)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RangeMapRemove(rmaphandle: *const ::core::ffi::c_void, usertag: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapRemove(rmaphandle: *const ::core::ffi::c_void, usertag: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(RangeMapRemove(::core::mem::transmute(rmaphandle), ::core::mem::transmute(usertag)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RangeMapWrite(rmaphandle: *const ::core::ffi::c_void, offset: u64, buffer: *const ::core::ffi::c_void, requestbytes: u32, flags: u32, donebytes: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RangeMapWrite(rmaphandle: *const ::core::ffi::c_void, offset: u64, buffer: *const ::core::ffi::c_void, requestbytes: u32, flags: u32, donebytes: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(RangeMapWrite(::core::mem::transmute(rmaphandle), ::core::mem::transmute(offset), ::core::mem::transmute(buffer), ::core::mem::transmute(requestbytes), ::core::mem::transmute(flags), ::core::mem::transmute(donebytes)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct RawSearchFlags(pub i32);
pub const RawSearchNone: RawSearchFlags = RawSearchFlags(0i32);
pub const RawSearchNoBases: RawSearchFlags = RawSearchFlags(1i32);
impl ::core::convert::From<i32> for RawSearchFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for RawSearchFlags {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ReBaseImage<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(
currentimagename: Param0,
symbolpath: Param1,
frebase: Param2,
frebasesysfileok: Param3,
fgoingdown: Param4,
checkimagesize: u32,
oldimagesize: *mut u32,
oldimagebase: *mut usize,
newimagesize: *mut u32,
newimagebase: *mut usize,
timestamp: u32,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ReBaseImage(currentimagename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, frebase: super::super::super::Foundation::BOOL, frebasesysfileok: super::super::super::Foundation::BOOL, fgoingdown: super::super::super::Foundation::BOOL, checkimagesize: u32, oldimagesize: *mut u32, oldimagebase: *mut usize, newimagesize: *mut u32, newimagebase: *mut usize, timestamp: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ReBaseImage(
currentimagename.into_param().abi(),
symbolpath.into_param().abi(),
frebase.into_param().abi(),
frebasesysfileok.into_param().abi(),
fgoingdown.into_param().abi(),
::core::mem::transmute(checkimagesize),
::core::mem::transmute(oldimagesize),
::core::mem::transmute(oldimagebase),
::core::mem::transmute(newimagesize),
::core::mem::transmute(newimagebase),
::core::mem::transmute(timestamp),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ReBaseImage64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(
currentimagename: Param0,
symbolpath: Param1,
frebase: Param2,
frebasesysfileok: Param3,
fgoingdown: Param4,
checkimagesize: u32,
oldimagesize: *mut u32,
oldimagebase: *mut u64,
newimagesize: *mut u32,
newimagebase: *mut u64,
timestamp: u32,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ReBaseImage64(currentimagename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, frebase: super::super::super::Foundation::BOOL, frebasesysfileok: super::super::super::Foundation::BOOL, fgoingdown: super::super::super::Foundation::BOOL, checkimagesize: u32, oldimagesize: *mut u32, oldimagebase: *mut u64, newimagesize: *mut u32, newimagebase: *mut u64, timestamp: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ReBaseImage64(
currentimagename.into_param().abi(),
symbolpath.into_param().abi(),
frebase.into_param().abi(),
frebasesysfileok.into_param().abi(),
fgoingdown.into_param().abi(),
::core::mem::transmute(checkimagesize),
::core::mem::transmute(oldimagesize),
::core::mem::transmute(oldimagebase),
::core::mem::transmute(newimagesize),
::core::mem::transmute(newimagebase),
::core::mem::transmute(timestamp),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ReadProcessMemory<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, lpbaseaddress: *const ::core::ffi::c_void, lpbuffer: *mut ::core::ffi::c_void, nsize: usize, lpnumberofbytesread: *mut usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ReadProcessMemory(hprocess: super::super::super::Foundation::HANDLE, lpbaseaddress: *const ::core::ffi::c_void, lpbuffer: *mut ::core::ffi::c_void, nsize: usize, lpnumberofbytesread: *mut usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ReadProcessMemory(hprocess.into_param().abi(), ::core::mem::transmute(lpbaseaddress), ::core::mem::transmute(lpbuffer), ::core::mem::transmute(nsize), ::core::mem::transmute(lpnumberofbytesread)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RegisterWaitChainCOMCallback(callstatecallback: ::core::option::Option<PCOGETCALLSTATE>, activationstatecallback: ::core::option::Option<PCOGETACTIVATIONSTATE>) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RegisterWaitChainCOMCallback(callstatecallback: ::windows::core::RawPtr, activationstatecallback: ::windows::core::RawPtr);
}
::core::mem::transmute(RegisterWaitChainCOMCallback(::core::mem::transmute(callstatecallback), ::core::mem::transmute(activationstatecallback)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RemoveInvalidModuleList<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RemoveInvalidModuleList(hprocess: super::super::super::Foundation::HANDLE);
}
::core::mem::transmute(RemoveInvalidModuleList(hprocess.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RemoveVectoredContinueHandler(handle: *const ::core::ffi::c_void) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RemoveVectoredContinueHandler(handle: *const ::core::ffi::c_void) -> u32;
}
::core::mem::transmute(RemoveVectoredContinueHandler(::core::mem::transmute(handle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RemoveVectoredExceptionHandler(handle: *const ::core::ffi::c_void) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RemoveVectoredExceptionHandler(handle: *const ::core::ffi::c_void) -> u32;
}
::core::mem::transmute(RemoveVectoredExceptionHandler(::core::mem::transmute(handle)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn ReportSymbolLoadSummary<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, ploadmodule: Param1, psymboldata: *const DBGHELP_DATA_REPORT_STRUCT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn ReportSymbolLoadSummary(hprocess: super::super::super::Foundation::HANDLE, ploadmodule: super::super::super::Foundation::PWSTR, psymboldata: *const DBGHELP_DATA_REPORT_STRUCT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(ReportSymbolLoadSummary(hprocess.into_param().abi(), ploadmodule.into_param().abi(), ::core::mem::transmute(psymboldata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlAddFunctionTable(functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, entrycount: u32, baseaddress: usize) -> super::super::super::Foundation::BOOLEAN {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlAddFunctionTable(functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, entrycount: u32, baseaddress: usize) -> super::super::super::Foundation::BOOLEAN;
}
::core::mem::transmute(RtlAddFunctionTable(::core::mem::transmute(functiontable), ::core::mem::transmute(entrycount), ::core::mem::transmute(baseaddress)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlAddFunctionTable(functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY, entrycount: u32, baseaddress: u64) -> super::super::super::Foundation::BOOLEAN {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlAddFunctionTable(functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY, entrycount: u32, baseaddress: u64) -> super::super::super::Foundation::BOOLEAN;
}
::core::mem::transmute(RtlAddFunctionTable(::core::mem::transmute(functiontable), ::core::mem::transmute(entrycount), ::core::mem::transmute(baseaddress)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "aarch64",))]
#[inline]
pub unsafe fn RtlAddGrowableFunctionTable(dynamictable: *mut *mut ::core::ffi::c_void, functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, entrycount: u32, maximumentrycount: u32, rangebase: usize, rangeend: usize) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlAddGrowableFunctionTable(dynamictable: *mut *mut ::core::ffi::c_void, functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, entrycount: u32, maximumentrycount: u32, rangebase: usize, rangeend: usize) -> u32;
}
::core::mem::transmute(RtlAddGrowableFunctionTable(::core::mem::transmute(dynamictable), ::core::mem::transmute(functiontable), ::core::mem::transmute(entrycount), ::core::mem::transmute(maximumentrycount), ::core::mem::transmute(rangebase), ::core::mem::transmute(rangeend)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[inline]
pub unsafe fn RtlAddGrowableFunctionTable(dynamictable: *mut *mut ::core::ffi::c_void, functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY, entrycount: u32, maximumentrycount: u32, rangebase: usize, rangeend: usize) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlAddGrowableFunctionTable(dynamictable: *mut *mut ::core::ffi::c_void, functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY, entrycount: u32, maximumentrycount: u32, rangebase: usize, rangeend: usize) -> u32;
}
::core::mem::transmute(RtlAddGrowableFunctionTable(::core::mem::transmute(dynamictable), ::core::mem::transmute(functiontable), ::core::mem::transmute(entrycount), ::core::mem::transmute(maximumentrycount), ::core::mem::transmute(rangebase), ::core::mem::transmute(rangeend)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_System_Kernel")]
#[inline]
pub unsafe fn RtlCaptureContext(contextrecord: *mut CONTEXT) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlCaptureContext(contextrecord: *mut CONTEXT);
}
::core::mem::transmute(RtlCaptureContext(::core::mem::transmute(contextrecord)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_System_Kernel")]
#[inline]
pub unsafe fn RtlCaptureContext2(contextrecord: *mut CONTEXT) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlCaptureContext2(contextrecord: *mut CONTEXT);
}
::core::mem::transmute(RtlCaptureContext2(::core::mem::transmute(contextrecord)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RtlCaptureStackBackTrace(framestoskip: u32, framestocapture: u32, backtrace: *mut *mut ::core::ffi::c_void, backtracehash: *mut u32) -> u16 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlCaptureStackBackTrace(framestoskip: u32, framestocapture: u32, backtrace: *mut *mut ::core::ffi::c_void, backtracehash: *mut u32) -> u16;
}
::core::mem::transmute(RtlCaptureStackBackTrace(::core::mem::transmute(framestoskip), ::core::mem::transmute(framestocapture), ::core::mem::transmute(backtrace), ::core::mem::transmute(backtracehash)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlDeleteFunctionTable(functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY) -> super::super::super::Foundation::BOOLEAN {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlDeleteFunctionTable(functiontable: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY) -> super::super::super::Foundation::BOOLEAN;
}
::core::mem::transmute(RtlDeleteFunctionTable(::core::mem::transmute(functiontable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlDeleteFunctionTable(functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY) -> super::super::super::Foundation::BOOLEAN {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlDeleteFunctionTable(functiontable: *const IMAGE_RUNTIME_FUNCTION_ENTRY) -> super::super::super::Foundation::BOOLEAN;
}
::core::mem::transmute(RtlDeleteFunctionTable(::core::mem::transmute(functiontable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn RtlDeleteGrowableFunctionTable(dynamictable: *const ::core::ffi::c_void) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlDeleteGrowableFunctionTable(dynamictable: *const ::core::ffi::c_void);
}
::core::mem::transmute(RtlDeleteGrowableFunctionTable(::core::mem::transmute(dynamictable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[inline]
pub unsafe fn RtlGrowFunctionTable(dynamictable: *mut ::core::ffi::c_void, newentrycount: u32) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlGrowFunctionTable(dynamictable: *mut ::core::ffi::c_void, newentrycount: u32);
}
::core::mem::transmute(RtlGrowFunctionTable(::core::mem::transmute(dynamictable), ::core::mem::transmute(newentrycount)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlInstallFunctionTableCallback<'a, Param5: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(tableidentifier: u64, baseaddress: u64, length: u32, callback: ::core::option::Option<PGET_RUNTIME_FUNCTION_CALLBACK>, context: *const ::core::ffi::c_void, outofprocesscallbackdll: Param5) -> super::super::super::Foundation::BOOLEAN {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlInstallFunctionTableCallback(tableidentifier: u64, baseaddress: u64, length: u32, callback: ::windows::core::RawPtr, context: *const ::core::ffi::c_void, outofprocesscallbackdll: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOLEAN;
}
::core::mem::transmute(RtlInstallFunctionTableCallback(::core::mem::transmute(tableidentifier), ::core::mem::transmute(baseaddress), ::core::mem::transmute(length), ::core::mem::transmute(callback), ::core::mem::transmute(context), outofprocesscallbackdll.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "aarch64",))]
#[inline]
pub unsafe fn RtlLookupFunctionEntry(controlpc: usize, imagebase: *mut usize, historytable: *mut UNWIND_HISTORY_TABLE) -> *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlLookupFunctionEntry(controlpc: usize, imagebase: *mut usize, historytable: *mut UNWIND_HISTORY_TABLE) -> *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY;
}
::core::mem::transmute(RtlLookupFunctionEntry(::core::mem::transmute(controlpc), ::core::mem::transmute(imagebase), ::core::mem::transmute(historytable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[inline]
pub unsafe fn RtlLookupFunctionEntry(controlpc: u64, imagebase: *mut u64, historytable: *mut UNWIND_HISTORY_TABLE) -> *mut IMAGE_RUNTIME_FUNCTION_ENTRY {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlLookupFunctionEntry(controlpc: u64, imagebase: *mut u64, historytable: *mut UNWIND_HISTORY_TABLE) -> *mut IMAGE_RUNTIME_FUNCTION_ENTRY;
}
::core::mem::transmute(RtlLookupFunctionEntry(::core::mem::transmute(controlpc), ::core::mem::transmute(imagebase), ::core::mem::transmute(historytable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn RtlPcToFileHeader(pcvalue: *const ::core::ffi::c_void, baseofimage: *mut *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlPcToFileHeader(pcvalue: *const ::core::ffi::c_void, baseofimage: *mut *mut ::core::ffi::c_void) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(RtlPcToFileHeader(::core::mem::transmute(pcvalue), ::core::mem::transmute(baseofimage)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlRaiseException(exceptionrecord: *const EXCEPTION_RECORD) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlRaiseException(exceptionrecord: *const EXCEPTION_RECORD);
}
::core::mem::transmute(RtlRaiseException(::core::mem::transmute(exceptionrecord)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn RtlRestoreContext(contextrecord: *const CONTEXT, exceptionrecord: *const EXCEPTION_RECORD) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlRestoreContext(contextrecord: *const CONTEXT, exceptionrecord: *const EXCEPTION_RECORD);
}
::core::mem::transmute(RtlRestoreContext(::core::mem::transmute(contextrecord), ::core::mem::transmute(exceptionrecord)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn RtlUnwind(targetframe: *const ::core::ffi::c_void, targetip: *const ::core::ffi::c_void, exceptionrecord: *const EXCEPTION_RECORD, returnvalue: *const ::core::ffi::c_void) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlUnwind(targetframe: *const ::core::ffi::c_void, targetip: *const ::core::ffi::c_void, exceptionrecord: *const EXCEPTION_RECORD, returnvalue: *const ::core::ffi::c_void);
}
::core::mem::transmute(RtlUnwind(::core::mem::transmute(targetframe), ::core::mem::transmute(targetip), ::core::mem::transmute(exceptionrecord), ::core::mem::transmute(returnvalue)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn RtlUnwindEx(targetframe: *const ::core::ffi::c_void, targetip: *const ::core::ffi::c_void, exceptionrecord: *const EXCEPTION_RECORD, returnvalue: *const ::core::ffi::c_void, contextrecord: *const CONTEXT, historytable: *const UNWIND_HISTORY_TABLE) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlUnwindEx(targetframe: *const ::core::ffi::c_void, targetip: *const ::core::ffi::c_void, exceptionrecord: *const EXCEPTION_RECORD, returnvalue: *const ::core::ffi::c_void, contextrecord: *const CONTEXT, historytable: *const UNWIND_HISTORY_TABLE);
}
::core::mem::transmute(RtlUnwindEx(::core::mem::transmute(targetframe), ::core::mem::transmute(targetip), ::core::mem::transmute(exceptionrecord), ::core::mem::transmute(returnvalue), ::core::mem::transmute(contextrecord), ::core::mem::transmute(historytable)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn RtlVirtualUnwind(handlertype: RTL_VIRTUAL_UNWIND_HANDLER_TYPE, imagebase: usize, controlpc: usize, functionentry: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, contextrecord: *mut CONTEXT, handlerdata: *mut *mut ::core::ffi::c_void, establisherframe: *mut usize, contextpointers: *mut KNONVOLATILE_CONTEXT_POINTERS_ARM64) -> ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlVirtualUnwind(handlertype: RTL_VIRTUAL_UNWIND_HANDLER_TYPE, imagebase: usize, controlpc: usize, functionentry: *const IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY, contextrecord: *mut CONTEXT, handlerdata: *mut *mut ::core::ffi::c_void, establisherframe: *mut usize, contextpointers: *mut KNONVOLATILE_CONTEXT_POINTERS_ARM64) -> ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE>;
}
::core::mem::transmute(RtlVirtualUnwind(
::core::mem::transmute(handlertype),
::core::mem::transmute(imagebase),
::core::mem::transmute(controlpc),
::core::mem::transmute(functionentry),
::core::mem::transmute(contextrecord),
::core::mem::transmute(handlerdata),
::core::mem::transmute(establisherframe),
::core::mem::transmute(contextpointers),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn RtlVirtualUnwind(handlertype: RTL_VIRTUAL_UNWIND_HANDLER_TYPE, imagebase: u64, controlpc: u64, functionentry: *const IMAGE_RUNTIME_FUNCTION_ENTRY, contextrecord: *mut CONTEXT, handlerdata: *mut *mut ::core::ffi::c_void, establisherframe: *mut u64, contextpointers: *mut KNONVOLATILE_CONTEXT_POINTERS) -> ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn RtlVirtualUnwind(handlertype: RTL_VIRTUAL_UNWIND_HANDLER_TYPE, imagebase: u64, controlpc: u64, functionentry: *const IMAGE_RUNTIME_FUNCTION_ENTRY, contextrecord: *mut CONTEXT, handlerdata: *mut *mut ::core::ffi::c_void, establisherframe: *mut u64, contextpointers: *mut KNONVOLATILE_CONTEXT_POINTERS) -> ::core::option::Option<super::super::Kernel::EXCEPTION_ROUTINE>;
}
::core::mem::transmute(RtlVirtualUnwind(
::core::mem::transmute(handlertype),
::core::mem::transmute(imagebase),
::core::mem::transmute(controlpc),
::core::mem::transmute(functionentry),
::core::mem::transmute(contextrecord),
::core::mem::transmute(handlerdata),
::core::mem::transmute(establisherframe),
::core::mem::transmute(contextpointers),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTGCTYPE(pub i32);
pub const SCRIPTGCTYPE_NORMAL: SCRIPTGCTYPE = SCRIPTGCTYPE(0i32);
pub const SCRIPTGCTYPE_EXHAUSTIVE: SCRIPTGCTYPE = SCRIPTGCTYPE(1i32);
impl ::core::convert::From<i32> for SCRIPTGCTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTGCTYPE {
type Abi = Self;
}
pub const SCRIPTINFO_ITYPEINFO: u32 = 2u32;
pub const SCRIPTINFO_IUNKNOWN: u32 = 1u32;
pub const SCRIPTINTERRUPT_DEBUG: u32 = 1u32;
pub const SCRIPTINTERRUPT_RAISEEXCEPTION: u32 = 2u32;
pub const SCRIPTITEM_CODEONLY: u32 = 512u32;
pub const SCRIPTITEM_GLOBALMEMBERS: u32 = 8u32;
pub const SCRIPTITEM_ISPERSISTENT: u32 = 64u32;
pub const SCRIPTITEM_ISSOURCE: u32 = 4u32;
pub const SCRIPTITEM_ISVISIBLE: u32 = 2u32;
pub const SCRIPTITEM_NOCODE: u32 = 1024u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTLANGUAGEVERSION(pub i32);
pub const SCRIPTLANGUAGEVERSION_DEFAULT: SCRIPTLANGUAGEVERSION = SCRIPTLANGUAGEVERSION(0i32);
pub const SCRIPTLANGUAGEVERSION_5_7: SCRIPTLANGUAGEVERSION = SCRIPTLANGUAGEVERSION(1i32);
pub const SCRIPTLANGUAGEVERSION_5_8: SCRIPTLANGUAGEVERSION = SCRIPTLANGUAGEVERSION(2i32);
pub const SCRIPTLANGUAGEVERSION_MAX: SCRIPTLANGUAGEVERSION = SCRIPTLANGUAGEVERSION(255i32);
impl ::core::convert::From<i32> for SCRIPTLANGUAGEVERSION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTLANGUAGEVERSION {
type Abi = Self;
}
pub const SCRIPTPROC_HOSTMANAGESSOURCE: u32 = 128u32;
pub const SCRIPTPROC_IMPLICIT_PARENTS: u32 = 512u32;
pub const SCRIPTPROC_IMPLICIT_THIS: u32 = 256u32;
pub const SCRIPTPROC_ISEXPRESSION: u32 = 32u32;
pub const SCRIPTPROC_ISXDOMAIN: u32 = 1024u32;
pub const SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION: u32 = 1879048194u32;
pub const SCRIPTPROP_BUILDNUMBER: u32 = 3u32;
pub const SCRIPTPROP_CATCHEXCEPTION: u32 = 4097u32;
pub const SCRIPTPROP_CONVERSIONLCID: u32 = 4098u32;
pub const SCRIPTPROP_DEBUGGER: u32 = 4352u32;
pub const SCRIPTPROP_DELAYEDEVENTSINKING: u32 = 4096u32;
pub const SCRIPTPROP_GCCONTROLSOFTCLOSE: u32 = 8192u32;
pub const SCRIPTPROP_HACK_FIBERSUPPORT: u32 = 1879048192u32;
pub const SCRIPTPROP_HACK_TRIDENTEVENTSINK: u32 = 1879048193u32;
pub const SCRIPTPROP_HOSTKEEPALIVE: u32 = 1879048196u32;
pub const SCRIPTPROP_HOSTSTACKREQUIRED: u32 = 4099u32;
pub const SCRIPTPROP_INTEGERMODE: u32 = 12288u32;
pub const SCRIPTPROP_INVOKEVERSIONING: u32 = 16384u32;
pub const SCRIPTPROP_JITDEBUG: u32 = 4353u32;
pub const SCRIPTPROP_MAJORVERSION: u32 = 1u32;
pub const SCRIPTPROP_MINORVERSION: u32 = 2u32;
pub const SCRIPTPROP_NAME: u32 = 0u32;
pub const SCRIPTPROP_SCRIPTSAREFULLYTRUSTED: u32 = 4100u32;
pub const SCRIPTPROP_STRINGCOMPAREINSTANCE: u32 = 12289u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTSTATE(pub i32);
pub const SCRIPTSTATE_UNINITIALIZED: SCRIPTSTATE = SCRIPTSTATE(0i32);
pub const SCRIPTSTATE_INITIALIZED: SCRIPTSTATE = SCRIPTSTATE(5i32);
pub const SCRIPTSTATE_STARTED: SCRIPTSTATE = SCRIPTSTATE(1i32);
pub const SCRIPTSTATE_CONNECTED: SCRIPTSTATE = SCRIPTSTATE(2i32);
pub const SCRIPTSTATE_DISCONNECTED: SCRIPTSTATE = SCRIPTSTATE(3i32);
pub const SCRIPTSTATE_CLOSED: SCRIPTSTATE = SCRIPTSTATE(4i32);
impl ::core::convert::From<i32> for SCRIPTSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTSTATE {
type Abi = Self;
}
pub const SCRIPTSTAT_INSTRUCTION_COUNT: u32 = 2u32;
pub const SCRIPTSTAT_INTSTRUCTION_TIME: u32 = 3u32;
pub const SCRIPTSTAT_STATEMENT_COUNT: u32 = 1u32;
pub const SCRIPTSTAT_TOTAL_TIME: u32 = 4u32;
pub const SCRIPTTEXT_DELAYEXECUTION: u32 = 1u32;
pub const SCRIPTTEXT_HOSTMANAGESSOURCE: u32 = 128u32;
pub const SCRIPTTEXT_ISEXPRESSION: u32 = 32u32;
pub const SCRIPTTEXT_ISNONUSERCODE: u32 = 512u32;
pub const SCRIPTTEXT_ISPERSISTENT: u32 = 64u32;
pub const SCRIPTTEXT_ISVISIBLE: u32 = 2u32;
pub const SCRIPTTEXT_ISXDOMAIN: u32 = 256u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTTHREADSTATE(pub i32);
pub const SCRIPTTHREADSTATE_NOTINSCRIPT: SCRIPTTHREADSTATE = SCRIPTTHREADSTATE(0i32);
pub const SCRIPTTHREADSTATE_RUNNING: SCRIPTTHREADSTATE = SCRIPTTHREADSTATE(1i32);
impl ::core::convert::From<i32> for SCRIPTTHREADSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTTHREADSTATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTTRACEINFO(pub i32);
pub const SCRIPTTRACEINFO_SCRIPTSTART: SCRIPTTRACEINFO = SCRIPTTRACEINFO(0i32);
pub const SCRIPTTRACEINFO_SCRIPTEND: SCRIPTTRACEINFO = SCRIPTTRACEINFO(1i32);
pub const SCRIPTTRACEINFO_COMCALLSTART: SCRIPTTRACEINFO = SCRIPTTRACEINFO(2i32);
pub const SCRIPTTRACEINFO_COMCALLEND: SCRIPTTRACEINFO = SCRIPTTRACEINFO(3i32);
pub const SCRIPTTRACEINFO_CREATEOBJSTART: SCRIPTTRACEINFO = SCRIPTTRACEINFO(4i32);
pub const SCRIPTTRACEINFO_CREATEOBJEND: SCRIPTTRACEINFO = SCRIPTTRACEINFO(5i32);
pub const SCRIPTTRACEINFO_GETOBJSTART: SCRIPTTRACEINFO = SCRIPTTRACEINFO(6i32);
pub const SCRIPTTRACEINFO_GETOBJEND: SCRIPTTRACEINFO = SCRIPTTRACEINFO(7i32);
impl ::core::convert::From<i32> for SCRIPTTRACEINFO {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTTRACEINFO {
type Abi = Self;
}
pub const SCRIPTTYPELIB_ISCONTROL: u32 = 16u32;
pub const SCRIPTTYPELIB_ISPERSISTENT: u32 = 64u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTUICHANDLING(pub i32);
pub const SCRIPTUICHANDLING_ALLOW: SCRIPTUICHANDLING = SCRIPTUICHANDLING(0i32);
pub const SCRIPTUICHANDLING_NOUIERROR: SCRIPTUICHANDLING = SCRIPTUICHANDLING(1i32);
pub const SCRIPTUICHANDLING_NOUIDEFAULT: SCRIPTUICHANDLING = SCRIPTUICHANDLING(2i32);
impl ::core::convert::From<i32> for SCRIPTUICHANDLING {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTUICHANDLING {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPTUICITEM(pub i32);
pub const SCRIPTUICITEM_INPUTBOX: SCRIPTUICITEM = SCRIPTUICITEM(1i32);
pub const SCRIPTUICITEM_MSGBOX: SCRIPTUICITEM = SCRIPTUICITEM(2i32);
impl ::core::convert::From<i32> for SCRIPTUICITEM {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPTUICITEM {
type Abi = Self;
}
pub const SCRIPT_CMPL_COMMIT: u32 = 4u32;
pub const SCRIPT_CMPL_ENUMLIST: u32 = 2u32;
pub const SCRIPT_CMPL_ENUM_TRIGGER: u32 = 1u32;
pub const SCRIPT_CMPL_GLOBALLIST: u32 = 8u32;
pub const SCRIPT_CMPL_MEMBERLIST: u32 = 1u32;
pub const SCRIPT_CMPL_MEMBER_TRIGGER: u32 = 2u32;
pub const SCRIPT_CMPL_NOLIST: u32 = 0u32;
pub const SCRIPT_CMPL_PARAMTIP: u32 = 4u32;
pub const SCRIPT_CMPL_PARAM_TRIGGER: u32 = 3u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPT_DEBUGGER_OPTIONS(pub i32);
pub const SDO_NONE: SCRIPT_DEBUGGER_OPTIONS = SCRIPT_DEBUGGER_OPTIONS(0i32);
pub const SDO_ENABLE_FIRST_CHANCE_EXCEPTIONS: SCRIPT_DEBUGGER_OPTIONS = SCRIPT_DEBUGGER_OPTIONS(1i32);
pub const SDO_ENABLE_WEB_WORKER_SUPPORT: SCRIPT_DEBUGGER_OPTIONS = SCRIPT_DEBUGGER_OPTIONS(2i32);
pub const SDO_ENABLE_NONUSER_CODE_SUPPORT: SCRIPT_DEBUGGER_OPTIONS = SCRIPT_DEBUGGER_OPTIONS(4i32);
pub const SDO_ENABLE_LIBRARY_STACK_FRAME: SCRIPT_DEBUGGER_OPTIONS = SCRIPT_DEBUGGER_OPTIONS(8i32);
impl ::core::convert::From<i32> for SCRIPT_DEBUGGER_OPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPT_DEBUGGER_OPTIONS {
type Abi = Self;
}
pub const SCRIPT_ENCODE_DEFAULT_LANGUAGE: u32 = 1u32;
pub const SCRIPT_ENCODE_NO_ASP_LANGUAGE: u32 = 2u32;
pub const SCRIPT_ENCODE_SECTION: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND(pub i32);
pub const ETK_FIRST_CHANCE: SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND = SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND(0i32);
pub const ETK_USER_UNHANDLED: SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND = SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND(1i32);
pub const ETK_UNHANDLED: SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND = SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND(2i32);
impl ::core::convert::From<i32> for SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPT_ERROR_DEBUG_EXCEPTION_THROWN_KIND {
type Abi = Self;
}
pub const SCRIPT_E_PROPAGATE: i32 = -2147352318i32;
pub const SCRIPT_E_RECORDED: i32 = -2040119292i32;
pub const SCRIPT_E_REPORTED: i32 = -2147352319i32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SCRIPT_INVOCATION_CONTEXT_TYPE(pub i32);
pub const SICT_Event: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(0i32);
pub const SICT_SetTimeout: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(1i32);
pub const SICT_SetInterval: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(2i32);
pub const SICT_SetImmediate: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(3i32);
pub const SICT_RequestAnimationFrame: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(4i32);
pub const SICT_ToString: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(5i32);
pub const SICT_MutationObserverCheckpoint: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(6i32);
pub const SICT_WWAExecUnsafeLocalFunction: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(7i32);
pub const SICT_WWAExecAtPriority: SCRIPT_INVOCATION_CONTEXT_TYPE = SCRIPT_INVOCATION_CONTEXT_TYPE(8i32);
impl ::core::convert::From<i32> for SCRIPT_INVOCATION_CONTEXT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SCRIPT_INVOCATION_CONTEXT_TYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SEARCHMEMORY {
pub SearchAddress: u64,
pub SearchLength: u64,
pub FoundAddress: u64,
pub PatternLength: u32,
pub Pattern: *mut ::core::ffi::c_void,
}
impl SEARCHMEMORY {}
impl ::core::default::Default for SEARCHMEMORY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SEARCHMEMORY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SEARCHMEMORY").field("SearchAddress", &self.SearchAddress).field("SearchLength", &self.SearchLength).field("FoundAddress", &self.FoundAddress).field("PatternLength", &self.PatternLength).field("Pattern", &self.Pattern).finish()
}
}
impl ::core::cmp::PartialEq for SEARCHMEMORY {
fn eq(&self, other: &Self) -> bool {
self.SearchAddress == other.SearchAddress && self.SearchLength == other.SearchLength && self.FoundAddress == other.FoundAddress && self.PatternLength == other.PatternLength && self.Pattern == other.Pattern
}
}
impl ::core::cmp::Eq for SEARCHMEMORY {}
unsafe impl ::windows::core::Abi for SEARCHMEMORY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SOURCEFILE {
pub ModBase: u64,
pub FileName: super::super::super::Foundation::PSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl SOURCEFILE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SOURCEFILE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SOURCEFILE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SOURCEFILE").field("ModBase", &self.ModBase).field("FileName", &self.FileName).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SOURCEFILE {
fn eq(&self, other: &Self) -> bool {
self.ModBase == other.ModBase && self.FileName == other.FileName
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SOURCEFILE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SOURCEFILE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SOURCEFILEW {
pub ModBase: u64,
pub FileName: super::super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl SOURCEFILEW {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SOURCEFILEW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SOURCEFILEW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SOURCEFILEW").field("ModBase", &self.ModBase).field("FileName", &self.FileName).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SOURCEFILEW {
fn eq(&self, other: &Self) -> bool {
self.ModBase == other.ModBase && self.FileName == other.FileName
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SOURCEFILEW {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SOURCEFILEW {
type Abi = Self;
}
pub const SOURCETEXT_ATTR_COMMENT: u32 = 2u32;
pub const SOURCETEXT_ATTR_FUNCTION_START: u32 = 64u32;
pub const SOURCETEXT_ATTR_HUMANTEXT: u32 = 32768u32;
pub const SOURCETEXT_ATTR_IDENTIFIER: u32 = 256u32;
pub const SOURCETEXT_ATTR_KEYWORD: u32 = 1u32;
pub const SOURCETEXT_ATTR_MEMBERLOOKUP: u32 = 512u32;
pub const SOURCETEXT_ATTR_NONSOURCE: u32 = 4u32;
pub const SOURCETEXT_ATTR_NUMBER: u32 = 16u32;
pub const SOURCETEXT_ATTR_OPERATOR: u32 = 8u32;
pub const SOURCETEXT_ATTR_STRING: u32 = 32u32;
pub const SOURCETEXT_ATTR_THIS: u32 = 1024u32;
pub const SPLITSYM_EXTRACT_ALL: u32 = 2u32;
pub const SPLITSYM_REMOVE_PRIVATE: u32 = 1u32;
pub const SPLITSYM_SYMBOLPATH_IS_SRC: u32 = 4u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SRCCODEINFO {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub ModBase: u64,
pub Obj: [super::super::super::Foundation::CHAR; 261],
pub FileName: [super::super::super::Foundation::CHAR; 261],
pub LineNumber: u32,
pub Address: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl SRCCODEINFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SRCCODEINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SRCCODEINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SRCCODEINFO").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("ModBase", &self.ModBase).field("Obj", &self.Obj).field("FileName", &self.FileName).field("LineNumber", &self.LineNumber).field("Address", &self.Address).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SRCCODEINFO {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.ModBase == other.ModBase && self.Obj == other.Obj && self.FileName == other.FileName && self.LineNumber == other.LineNumber && self.Address == other.Address
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SRCCODEINFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SRCCODEINFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SRCCODEINFOW {
pub SizeOfStruct: u32,
pub Key: *mut ::core::ffi::c_void,
pub ModBase: u64,
pub Obj: [u16; 261],
pub FileName: [u16; 261],
pub LineNumber: u32,
pub Address: u64,
}
impl SRCCODEINFOW {}
impl ::core::default::Default for SRCCODEINFOW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SRCCODEINFOW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SRCCODEINFOW").field("SizeOfStruct", &self.SizeOfStruct).field("Key", &self.Key).field("ModBase", &self.ModBase).field("Obj", &self.Obj).field("FileName", &self.FileName).field("LineNumber", &self.LineNumber).field("Address", &self.Address).finish()
}
}
impl ::core::cmp::PartialEq for SRCCODEINFOW {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Key == other.Key && self.ModBase == other.ModBase && self.Obj == other.Obj && self.FileName == other.FileName && self.LineNumber == other.LineNumber && self.Address == other.Address
}
}
impl ::core::cmp::Eq for SRCCODEINFOW {}
unsafe impl ::windows::core::Abi for SRCCODEINFOW {
type Abi = Self;
}
pub const SSRVACTION_CHECKSUMSTATUS: u32 = 8u32;
pub const SSRVACTION_EVENT: u32 = 3u32;
pub const SSRVACTION_EVENTW: u32 = 4u32;
pub const SSRVACTION_HTTPSTATUS: u32 = 6u32;
pub const SSRVACTION_QUERYCANCEL: u32 = 2u32;
pub const SSRVACTION_SIZE: u32 = 5u32;
pub const SSRVACTION_TRACE: u32 = 1u32;
pub const SSRVACTION_XMLOUTPUT: u32 = 7u32;
pub const SSRVOPT_CALLBACK: u32 = 1u32;
pub const SSRVOPT_CALLBACKW: u32 = 65536u32;
pub const SSRVOPT_DISABLE_PING_HOST: u32 = 67108864u32;
pub const SSRVOPT_DISABLE_TIMEOUT: u32 = 134217728u32;
pub const SSRVOPT_DONT_UNCOMPRESS: u32 = 33554432u32;
pub const SSRVOPT_DOWNSTREAM_STORE: u32 = 8192u32;
pub const SSRVOPT_ENABLE_COMM_MSG: u32 = 268435456u32;
pub const SSRVOPT_FAVOR_COMPRESSED: u32 = 2097152u32;
pub const SSRVOPT_FLAT_DEFAULT_STORE: u32 = 131072u32;
pub const SSRVOPT_GETPATH: u32 = 64u32;
pub const SSRVOPT_MAX: u32 = 2147483648u32;
pub const SSRVOPT_MESSAGE: u32 = 524288u32;
pub const SSRVOPT_NOCOPY: u32 = 64u32;
pub const SSRVOPT_OLDGUIDPTR: u32 = 16u32;
pub const SSRVOPT_OVERWRITE: u32 = 16384u32;
pub const SSRVOPT_PARAMTYPE: u32 = 256u32;
pub const SSRVOPT_PARENTWIN: u32 = 128u32;
pub const SSRVOPT_PROXY: u32 = 4096u32;
pub const SSRVOPT_PROXYW: u32 = 262144u32;
pub const SSRVOPT_RESETTOU: u32 = 32768u32;
pub const SSRVOPT_RETRY_APP_HANG: u32 = 2147483648u32;
pub const SSRVOPT_SECURE: u32 = 512u32;
pub const SSRVOPT_SERVICE: u32 = 1048576u32;
pub const SSRVOPT_SETCONTEXT: u32 = 2048u32;
pub const SSRVOPT_STRING: u32 = 4194304u32;
pub const SSRVOPT_TRACE: u32 = 1024u32;
pub const SSRVOPT_UNATTENDED: u32 = 32u32;
pub const SSRVOPT_URI_FILTER: u32 = 536870912u32;
pub const SSRVOPT_URI_TIERS: u32 = 1073741824u32;
pub const SSRVOPT_WINHTTP: u32 = 8388608u32;
pub const SSRVOPT_WININET: u32 = 16777216u32;
pub const SSRVURI_ALL: u32 = 255u32;
pub const SSRVURI_COMPRESSED: u32 = 2u32;
pub const SSRVURI_FILEPTR: u32 = 4u32;
pub const SSRVURI_HTTP_COMPRESSED: u32 = 2u32;
pub const SSRVURI_HTTP_FILEPTR: u32 = 4u32;
pub const SSRVURI_HTTP_MASK: u32 = 15u32;
pub const SSRVURI_HTTP_NORMAL: u32 = 1u32;
pub const SSRVURI_NORMAL: u32 = 1u32;
pub const SSRVURI_UNC_COMPRESSED: u32 = 32u32;
pub const SSRVURI_UNC_FILEPTR: u32 = 64u32;
pub const SSRVURI_UNC_MASK: u32 = 240u32;
pub const SSRVURI_UNC_NORMAL: u32 = 16u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
pub struct STACKFRAME {
pub AddrPC: ADDRESS,
pub AddrReturn: ADDRESS,
pub AddrFrame: ADDRESS,
pub AddrStack: ADDRESS,
pub FuncTableEntry: *mut ::core::ffi::c_void,
pub Params: [u32; 4],
pub Far: super::super::super::Foundation::BOOL,
pub Virtual: super::super::super::Foundation::BOOL,
pub Reserved: [u32; 3],
pub KdHelp: KDHELP,
pub AddrBStore: ADDRESS,
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl STACKFRAME {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for STACKFRAME {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for STACKFRAME {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STACKFRAME")
.field("AddrPC", &self.AddrPC)
.field("AddrReturn", &self.AddrReturn)
.field("AddrFrame", &self.AddrFrame)
.field("AddrStack", &self.AddrStack)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Far", &self.Far)
.field("Virtual", &self.Virtual)
.field("Reserved", &self.Reserved)
.field("KdHelp", &self.KdHelp)
.field("AddrBStore", &self.AddrBStore)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for STACKFRAME {
fn eq(&self, other: &Self) -> bool {
self.AddrPC == other.AddrPC && self.AddrReturn == other.AddrReturn && self.AddrFrame == other.AddrFrame && self.AddrStack == other.AddrStack && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Far == other.Far && self.Virtual == other.Virtual && self.Reserved == other.Reserved && self.KdHelp == other.KdHelp && self.AddrBStore == other.AddrBStore
}
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for STACKFRAME {}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for STACKFRAME {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct STACKFRAME64 {
pub AddrPC: ADDRESS64,
pub AddrReturn: ADDRESS64,
pub AddrFrame: ADDRESS64,
pub AddrStack: ADDRESS64,
pub AddrBStore: ADDRESS64,
pub FuncTableEntry: *mut ::core::ffi::c_void,
pub Params: [u64; 4],
pub Far: super::super::super::Foundation::BOOL,
pub Virtual: super::super::super::Foundation::BOOL,
pub Reserved: [u64; 3],
pub KdHelp: KDHELP64,
}
#[cfg(feature = "Win32_Foundation")]
impl STACKFRAME64 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for STACKFRAME64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for STACKFRAME64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STACKFRAME64")
.field("AddrPC", &self.AddrPC)
.field("AddrReturn", &self.AddrReturn)
.field("AddrFrame", &self.AddrFrame)
.field("AddrStack", &self.AddrStack)
.field("AddrBStore", &self.AddrBStore)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Far", &self.Far)
.field("Virtual", &self.Virtual)
.field("Reserved", &self.Reserved)
.field("KdHelp", &self.KdHelp)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for STACKFRAME64 {
fn eq(&self, other: &Self) -> bool {
self.AddrPC == other.AddrPC && self.AddrReturn == other.AddrReturn && self.AddrFrame == other.AddrFrame && self.AddrStack == other.AddrStack && self.AddrBStore == other.AddrBStore && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Far == other.Far && self.Virtual == other.Virtual && self.Reserved == other.Reserved && self.KdHelp == other.KdHelp
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for STACKFRAME64 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for STACKFRAME64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct STACKFRAME_EX {
pub AddrPC: ADDRESS64,
pub AddrReturn: ADDRESS64,
pub AddrFrame: ADDRESS64,
pub AddrStack: ADDRESS64,
pub AddrBStore: ADDRESS64,
pub FuncTableEntry: *mut ::core::ffi::c_void,
pub Params: [u64; 4],
pub Far: super::super::super::Foundation::BOOL,
pub Virtual: super::super::super::Foundation::BOOL,
pub Reserved: [u64; 3],
pub KdHelp: KDHELP64,
pub StackFrameSize: u32,
pub InlineFrameContext: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl STACKFRAME_EX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for STACKFRAME_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for STACKFRAME_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STACKFRAME_EX")
.field("AddrPC", &self.AddrPC)
.field("AddrReturn", &self.AddrReturn)
.field("AddrFrame", &self.AddrFrame)
.field("AddrStack", &self.AddrStack)
.field("AddrBStore", &self.AddrBStore)
.field("FuncTableEntry", &self.FuncTableEntry)
.field("Params", &self.Params)
.field("Far", &self.Far)
.field("Virtual", &self.Virtual)
.field("Reserved", &self.Reserved)
.field("KdHelp", &self.KdHelp)
.field("StackFrameSize", &self.StackFrameSize)
.field("InlineFrameContext", &self.InlineFrameContext)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for STACKFRAME_EX {
fn eq(&self, other: &Self) -> bool {
self.AddrPC == other.AddrPC && self.AddrReturn == other.AddrReturn && self.AddrFrame == other.AddrFrame && self.AddrStack == other.AddrStack && self.AddrBStore == other.AddrBStore && self.FuncTableEntry == other.FuncTableEntry && self.Params == other.Params && self.Far == other.Far && self.Virtual == other.Virtual && self.Reserved == other.Reserved && self.KdHelp == other.KdHelp && self.StackFrameSize == other.StackFrameSize && self.InlineFrameContext == other.InlineFrameContext
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for STACKFRAME_EX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for STACKFRAME_EX {
type Abi = Self;
}
pub const STACK_FRAME_TYPE_IGNORE: u32 = 255u32;
pub const STACK_FRAME_TYPE_INIT: u32 = 0u32;
pub const STACK_FRAME_TYPE_INLINE: u32 = 2u32;
pub const STACK_FRAME_TYPE_RA: u32 = 128u32;
pub const STACK_FRAME_TYPE_STACK: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct STACK_SRC_INFO {
pub ImagePath: super::super::super::Foundation::PWSTR,
pub ModuleName: super::super::super::Foundation::PWSTR,
pub Function: super::super::super::Foundation::PWSTR,
pub Displacement: u32,
pub Row: u32,
pub Column: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl STACK_SRC_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for STACK_SRC_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for STACK_SRC_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STACK_SRC_INFO").field("ImagePath", &self.ImagePath).field("ModuleName", &self.ModuleName).field("Function", &self.Function).field("Displacement", &self.Displacement).field("Row", &self.Row).field("Column", &self.Column).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for STACK_SRC_INFO {
fn eq(&self, other: &Self) -> bool {
self.ImagePath == other.ImagePath && self.ModuleName == other.ModuleName && self.Function == other.Function && self.Displacement == other.Displacement && self.Row == other.Row && self.Column == other.Column
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for STACK_SRC_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for STACK_SRC_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct STACK_SYM_FRAME_INFO {
pub StackFrameEx: DEBUG_STACK_FRAME_EX,
pub SrcInfo: STACK_SRC_INFO,
}
#[cfg(feature = "Win32_Foundation")]
impl STACK_SYM_FRAME_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for STACK_SYM_FRAME_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for STACK_SYM_FRAME_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("STACK_SYM_FRAME_INFO").field("StackFrameEx", &self.StackFrameEx).field("SrcInfo", &self.SrcInfo).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for STACK_SYM_FRAME_INFO {
fn eq(&self, other: &Self) -> bool {
self.StackFrameEx == other.StackFrameEx && self.SrcInfo == other.SrcInfo
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for STACK_SYM_FRAME_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for STACK_SYM_FRAME_INFO {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
pub type SYMADDSOURCESTREAM = unsafe extern "system" fn(param0: super::super::super::Foundation::HANDLE, param1: u64, param2: super::super::super::Foundation::PSTR, param3: *mut u8, param4: usize) -> super::super::super::Foundation::BOOL;
#[cfg(feature = "Win32_Foundation")]
pub type SYMADDSOURCESTREAMA = unsafe extern "system" fn(param0: super::super::super::Foundation::HANDLE, param1: u64, param2: super::super::super::Foundation::PSTR, param3: *mut u8, param4: usize) -> super::super::super::Foundation::BOOL;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SYMBOL_INFO {
pub SizeOfStruct: u32,
pub TypeIndex: u32,
pub Reserved: [u64; 2],
pub Index: u32,
pub Size: u32,
pub ModBase: u64,
pub Flags: SYMBOL_INFO_FLAGS,
pub Value: u64,
pub Address: u64,
pub Register: u32,
pub Scope: u32,
pub Tag: u32,
pub NameLen: u32,
pub MaxNameLen: u32,
pub Name: [super::super::super::Foundation::CHAR; 1],
}
#[cfg(feature = "Win32_Foundation")]
impl SYMBOL_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SYMBOL_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SYMBOL_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMBOL_INFO")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("TypeIndex", &self.TypeIndex)
.field("Reserved", &self.Reserved)
.field("Index", &self.Index)
.field("Size", &self.Size)
.field("ModBase", &self.ModBase)
.field("Flags", &self.Flags)
.field("Value", &self.Value)
.field("Address", &self.Address)
.field("Register", &self.Register)
.field("Scope", &self.Scope)
.field("Tag", &self.Tag)
.field("NameLen", &self.NameLen)
.field("MaxNameLen", &self.MaxNameLen)
.field("Name", &self.Name)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SYMBOL_INFO {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.TypeIndex == other.TypeIndex && self.Reserved == other.Reserved && self.Index == other.Index && self.Size == other.Size && self.ModBase == other.ModBase && self.Flags == other.Flags && self.Value == other.Value && self.Address == other.Address && self.Register == other.Register && self.Scope == other.Scope && self.Tag == other.Tag && self.NameLen == other.NameLen && self.MaxNameLen == other.MaxNameLen && self.Name == other.Name
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SYMBOL_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SYMBOL_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SYMBOL_INFOW {
pub SizeOfStruct: u32,
pub TypeIndex: u32,
pub Reserved: [u64; 2],
pub Index: u32,
pub Size: u32,
pub ModBase: u64,
pub Flags: SYMBOL_INFO_FLAGS,
pub Value: u64,
pub Address: u64,
pub Register: u32,
pub Scope: u32,
pub Tag: u32,
pub NameLen: u32,
pub MaxNameLen: u32,
pub Name: [u16; 1],
}
impl SYMBOL_INFOW {}
impl ::core::default::Default for SYMBOL_INFOW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SYMBOL_INFOW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMBOL_INFOW")
.field("SizeOfStruct", &self.SizeOfStruct)
.field("TypeIndex", &self.TypeIndex)
.field("Reserved", &self.Reserved)
.field("Index", &self.Index)
.field("Size", &self.Size)
.field("ModBase", &self.ModBase)
.field("Flags", &self.Flags)
.field("Value", &self.Value)
.field("Address", &self.Address)
.field("Register", &self.Register)
.field("Scope", &self.Scope)
.field("Tag", &self.Tag)
.field("NameLen", &self.NameLen)
.field("MaxNameLen", &self.MaxNameLen)
.field("Name", &self.Name)
.finish()
}
}
impl ::core::cmp::PartialEq for SYMBOL_INFOW {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.TypeIndex == other.TypeIndex && self.Reserved == other.Reserved && self.Index == other.Index && self.Size == other.Size && self.ModBase == other.ModBase && self.Flags == other.Flags && self.Value == other.Value && self.Address == other.Address && self.Register == other.Register && self.Scope == other.Scope && self.Tag == other.Tag && self.NameLen == other.NameLen && self.MaxNameLen == other.MaxNameLen && self.Name == other.Name
}
}
impl ::core::cmp::Eq for SYMBOL_INFOW {}
unsafe impl ::windows::core::Abi for SYMBOL_INFOW {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SYMBOL_INFO_EX {
pub SizeOfStruct: u32,
pub TypeOfInfo: u32,
pub Offset: u64,
pub Line: u32,
pub Displacement: u32,
pub Reserved: [u32; 4],
}
impl SYMBOL_INFO_EX {}
impl ::core::default::Default for SYMBOL_INFO_EX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SYMBOL_INFO_EX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMBOL_INFO_EX").field("SizeOfStruct", &self.SizeOfStruct).field("TypeOfInfo", &self.TypeOfInfo).field("Offset", &self.Offset).field("Line", &self.Line).field("Displacement", &self.Displacement).field("Reserved", &self.Reserved).finish()
}
}
impl ::core::cmp::PartialEq for SYMBOL_INFO_EX {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.TypeOfInfo == other.TypeOfInfo && self.Offset == other.Offset && self.Line == other.Line && self.Displacement == other.Displacement && self.Reserved == other.Reserved
}
}
impl ::core::cmp::Eq for SYMBOL_INFO_EX {}
unsafe impl ::windows::core::Abi for SYMBOL_INFO_EX {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SYMBOL_INFO_FLAGS(pub u32);
pub const SYMFLAG_CLR_TOKEN: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(262144u32);
pub const SYMFLAG_CONSTANT: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(256u32);
pub const SYMFLAG_EXPORT: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(512u32);
pub const SYMFLAG_FORWARDER: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(1024u32);
pub const SYMFLAG_FRAMEREL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(32u32);
pub const SYMFLAG_FUNCTION: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(2048u32);
pub const SYMFLAG_ILREL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(65536u32);
pub const SYMFLAG_LOCAL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(128u32);
pub const SYMFLAG_METADATA: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(131072u32);
pub const SYMFLAG_PARAMETER: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(64u32);
pub const SYMFLAG_REGISTER: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(8u32);
pub const SYMFLAG_REGREL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(16u32);
pub const SYMFLAG_SLOT: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(32768u32);
pub const SYMFLAG_THUNK: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(8192u32);
pub const SYMFLAG_TLSREL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(16384u32);
pub const SYMFLAG_VALUEPRESENT: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(1u32);
pub const SYMFLAG_VIRTUAL: SYMBOL_INFO_FLAGS = SYMBOL_INFO_FLAGS(4096u32);
impl ::core::convert::From<u32> for SYMBOL_INFO_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SYMBOL_INFO_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for SYMBOL_INFO_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SYMBOL_INFO_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SYMBOL_INFO_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SYMBOL_INFO_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SYMBOL_INFO_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SYMBOL_INFO_PACKAGE {
pub si: SYMBOL_INFO,
pub name: [super::super::super::Foundation::CHAR; 2001],
}
#[cfg(feature = "Win32_Foundation")]
impl SYMBOL_INFO_PACKAGE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SYMBOL_INFO_PACKAGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SYMBOL_INFO_PACKAGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMBOL_INFO_PACKAGE").field("si", &self.si).field("name", &self.name).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SYMBOL_INFO_PACKAGE {
fn eq(&self, other: &Self) -> bool {
self.si == other.si && self.name == other.name
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SYMBOL_INFO_PACKAGE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SYMBOL_INFO_PACKAGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SYMBOL_INFO_PACKAGEW {
pub si: SYMBOL_INFOW,
pub name: [u16; 2001],
}
impl SYMBOL_INFO_PACKAGEW {}
impl ::core::default::Default for SYMBOL_INFO_PACKAGEW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SYMBOL_INFO_PACKAGEW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMBOL_INFO_PACKAGEW").field("si", &self.si).field("name", &self.name).finish()
}
}
impl ::core::cmp::PartialEq for SYMBOL_INFO_PACKAGEW {
fn eq(&self, other: &Self) -> bool {
self.si == other.si && self.name == other.name
}
}
impl ::core::cmp::Eq for SYMBOL_INFO_PACKAGEW {}
unsafe impl ::windows::core::Abi for SYMBOL_INFO_PACKAGEW {
type Abi = Self;
}
pub const SYMBOL_TYPE_INDEX_NOT_FOUND: u32 = 2u32;
pub const SYMBOL_TYPE_INFO_NOT_FOUND: u32 = 3u32;
pub const SYMENUM_OPTIONS_DEFAULT: u32 = 1u32;
pub const SYMENUM_OPTIONS_INLINE: u32 = 2u32;
pub const SYMFLAG_FIXUP_ARM64X: u32 = 16777216u32;
pub const SYMFLAG_FUNC_NO_RETURN: u32 = 1048576u32;
pub const SYMFLAG_GLOBAL: u32 = 33554432u32;
pub const SYMFLAG_NULL: u32 = 524288u32;
pub const SYMFLAG_PUBLIC_CODE: u32 = 4194304u32;
pub const SYMFLAG_REGREL_ALIASINDIR: u32 = 8388608u32;
pub const SYMFLAG_RESET: u32 = 2147483648u32;
pub const SYMFLAG_SYNTHETIC_ZEROBASE: u32 = 2097152u32;
pub const SYMF_CONSTANT: u32 = 256u32;
pub const SYMF_EXPORT: u32 = 512u32;
pub const SYMF_FORWARDER: u32 = 1024u32;
pub const SYMF_FRAMEREL: u32 = 32u32;
pub const SYMF_FUNCTION: u32 = 2048u32;
pub const SYMF_LOCAL: u32 = 128u32;
pub const SYMF_OMAP_GENERATED: u32 = 1u32;
pub const SYMF_OMAP_MODIFIED: u32 = 2u32;
pub const SYMF_PARAMETER: u32 = 64u32;
pub const SYMF_REGISTER: u32 = 8u32;
pub const SYMF_REGREL: u32 = 16u32;
pub const SYMF_THUNK: u32 = 8192u32;
pub const SYMF_TLSREL: u32 = 16384u32;
pub const SYMF_VIRTUAL: u32 = 4096u32;
pub const SYMOPT_ALLOW_ABSOLUTE_SYMBOLS: u32 = 2048u32;
pub const SYMOPT_ALLOW_ZERO_ADDRESS: u32 = 16777216u32;
pub const SYMOPT_AUTO_PUBLICS: u32 = 65536u32;
pub const SYMOPT_CASE_INSENSITIVE: u32 = 1u32;
pub const SYMOPT_DEBUG: u32 = 2147483648u32;
pub const SYMOPT_DEFERRED_LOADS: u32 = 4u32;
pub const SYMOPT_DISABLE_FAST_SYMBOLS: u32 = 268435456u32;
pub const SYMOPT_DISABLE_SRVSTAR_ON_STARTUP: u32 = 1073741824u32;
pub const SYMOPT_DISABLE_SYMSRV_AUTODETECT: u32 = 33554432u32;
pub const SYMOPT_DISABLE_SYMSRV_TIMEOUT: u32 = 536870912u32;
pub const SYMOPT_EXACT_SYMBOLS: u32 = 1024u32;
pub const SYMOPT_FAIL_CRITICAL_ERRORS: u32 = 512u32;
pub const SYMOPT_FAVOR_COMPRESSED: u32 = 8388608u32;
pub const SYMOPT_FLAT_DIRECTORY: u32 = 4194304u32;
pub const SYMOPT_IGNORE_CVREC: u32 = 128u32;
pub const SYMOPT_IGNORE_IMAGEDIR: u32 = 2097152u32;
pub const SYMOPT_IGNORE_NT_SYMPATH: u32 = 4096u32;
pub const SYMOPT_INCLUDE_32BIT_MODULES: u32 = 8192u32;
pub const SYMOPT_LOAD_ANYTHING: u32 = 64u32;
pub const SYMOPT_LOAD_LINES: u32 = 16u32;
pub const SYMOPT_NO_CPP: u32 = 8u32;
pub const SYMOPT_NO_IMAGE_SEARCH: u32 = 131072u32;
pub const SYMOPT_NO_PROMPTS: u32 = 524288u32;
pub const SYMOPT_NO_PUBLICS: u32 = 32768u32;
pub const SYMOPT_NO_UNQUALIFIED_LOADS: u32 = 256u32;
pub const SYMOPT_OMAP_FIND_NEAREST: u32 = 32u32;
pub const SYMOPT_OVERWRITE: u32 = 1048576u32;
pub const SYMOPT_PUBLICS_ONLY: u32 = 16384u32;
pub const SYMOPT_READONLY_CACHE: u32 = 67108864u32;
pub const SYMOPT_SECURE: u32 = 262144u32;
pub const SYMOPT_SYMPATH_LAST: u32 = 134217728u32;
pub const SYMOPT_UNDNAME: u32 = 2u32;
pub const SYMSEARCH_ALLITEMS: u32 = 8u32;
pub const SYMSEARCH_GLOBALSONLY: u32 = 4u32;
pub const SYMSEARCH_MASKOBJS: u32 = 1u32;
pub const SYMSEARCH_RECURSE: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SYMSRV_EXTENDED_OUTPUT_DATA {
pub sizeOfStruct: u32,
pub version: u32,
pub filePtrMsg: [u16; 261],
}
impl SYMSRV_EXTENDED_OUTPUT_DATA {}
impl ::core::default::Default for SYMSRV_EXTENDED_OUTPUT_DATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SYMSRV_EXTENDED_OUTPUT_DATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMSRV_EXTENDED_OUTPUT_DATA").field("sizeOfStruct", &self.sizeOfStruct).field("version", &self.version).field("filePtrMsg", &self.filePtrMsg).finish()
}
}
impl ::core::cmp::PartialEq for SYMSRV_EXTENDED_OUTPUT_DATA {
fn eq(&self, other: &Self) -> bool {
self.sizeOfStruct == other.sizeOfStruct && self.version == other.version && self.filePtrMsg == other.filePtrMsg
}
}
impl ::core::cmp::Eq for SYMSRV_EXTENDED_OUTPUT_DATA {}
unsafe impl ::windows::core::Abi for SYMSRV_EXTENDED_OUTPUT_DATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SYMSRV_INDEX_INFO {
pub sizeofstruct: u32,
pub file: [super::super::super::Foundation::CHAR; 261],
pub stripped: super::super::super::Foundation::BOOL,
pub timestamp: u32,
pub size: u32,
pub dbgfile: [super::super::super::Foundation::CHAR; 261],
pub pdbfile: [super::super::super::Foundation::CHAR; 261],
pub guid: ::windows::core::GUID,
pub sig: u32,
pub age: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl SYMSRV_INDEX_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SYMSRV_INDEX_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SYMSRV_INDEX_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMSRV_INDEX_INFO")
.field("sizeofstruct", &self.sizeofstruct)
.field("file", &self.file)
.field("stripped", &self.stripped)
.field("timestamp", &self.timestamp)
.field("size", &self.size)
.field("dbgfile", &self.dbgfile)
.field("pdbfile", &self.pdbfile)
.field("guid", &self.guid)
.field("sig", &self.sig)
.field("age", &self.age)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SYMSRV_INDEX_INFO {
fn eq(&self, other: &Self) -> bool {
self.sizeofstruct == other.sizeofstruct && self.file == other.file && self.stripped == other.stripped && self.timestamp == other.timestamp && self.size == other.size && self.dbgfile == other.dbgfile && self.pdbfile == other.pdbfile && self.guid == other.guid && self.sig == other.sig && self.age == other.age
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SYMSRV_INDEX_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SYMSRV_INDEX_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SYMSRV_INDEX_INFOW {
pub sizeofstruct: u32,
pub file: [u16; 261],
pub stripped: super::super::super::Foundation::BOOL,
pub timestamp: u32,
pub size: u32,
pub dbgfile: [u16; 261],
pub pdbfile: [u16; 261],
pub guid: ::windows::core::GUID,
pub sig: u32,
pub age: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl SYMSRV_INDEX_INFOW {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SYMSRV_INDEX_INFOW {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SYMSRV_INDEX_INFOW {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SYMSRV_INDEX_INFOW")
.field("sizeofstruct", &self.sizeofstruct)
.field("file", &self.file)
.field("stripped", &self.stripped)
.field("timestamp", &self.timestamp)
.field("size", &self.size)
.field("dbgfile", &self.dbgfile)
.field("pdbfile", &self.pdbfile)
.field("guid", &self.guid)
.field("sig", &self.sig)
.field("age", &self.age)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SYMSRV_INDEX_INFOW {
fn eq(&self, other: &Self) -> bool {
self.sizeofstruct == other.sizeofstruct && self.file == other.file && self.stripped == other.stripped && self.timestamp == other.timestamp && self.size == other.size && self.dbgfile == other.dbgfile && self.pdbfile == other.pdbfile && self.guid == other.guid && self.sig == other.sig && self.age == other.age
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SYMSRV_INDEX_INFOW {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SYMSRV_INDEX_INFOW {
type Abi = Self;
}
pub const SYMSRV_VERSION: u32 = 2u32;
pub const SYMSTOREOPT_ALT_INDEX: u32 = 16u32;
pub const SYMSTOREOPT_UNICODE: u32 = 32u32;
impl ::core::clone::Clone for SYM_DUMP_PARAM {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
pub struct SYM_DUMP_PARAM {
pub size: u32,
pub sName: *mut u8,
pub Options: u32,
pub addr: u64,
pub listLink: *mut FIELD_INFO,
pub Anonymous: SYM_DUMP_PARAM_0,
pub CallbackRoutine: ::core::option::Option<PSYM_DUMP_FIELD_CALLBACK>,
pub nFields: u32,
pub Fields: *mut FIELD_INFO,
pub ModBase: u64,
pub TypeId: u32,
pub TypeSize: u32,
pub BufferSize: u32,
pub _bitfield: u32,
}
impl SYM_DUMP_PARAM {}
impl ::core::default::Default for SYM_DUMP_PARAM {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for SYM_DUMP_PARAM {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for SYM_DUMP_PARAM {}
unsafe impl ::windows::core::Abi for SYM_DUMP_PARAM {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union SYM_DUMP_PARAM_0 {
pub Context: *mut ::core::ffi::c_void,
pub pBuffer: *mut ::core::ffi::c_void,
}
impl SYM_DUMP_PARAM_0 {}
impl ::core::default::Default for SYM_DUMP_PARAM_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for SYM_DUMP_PARAM_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for SYM_DUMP_PARAM_0 {}
unsafe impl ::windows::core::Abi for SYM_DUMP_PARAM_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SYM_FIND_ID_OPTION(pub u32);
pub const SSRVOPT_DWORD: SYM_FIND_ID_OPTION = SYM_FIND_ID_OPTION(2u32);
pub const SSRVOPT_DWORDPTR: SYM_FIND_ID_OPTION = SYM_FIND_ID_OPTION(4u32);
pub const SSRVOPT_GUIDPTR: SYM_FIND_ID_OPTION = SYM_FIND_ID_OPTION(8u32);
impl ::core::convert::From<u32> for SYM_FIND_ID_OPTION {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SYM_FIND_ID_OPTION {
type Abi = Self;
}
impl ::core::ops::BitOr for SYM_FIND_ID_OPTION {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SYM_FIND_ID_OPTION {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SYM_FIND_ID_OPTION {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SYM_FIND_ID_OPTION {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SYM_FIND_ID_OPTION {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const SYM_INLINE_COMP_DIFFERENT: u32 = 5u32;
pub const SYM_INLINE_COMP_ERROR: u32 = 0u32;
pub const SYM_INLINE_COMP_IDENTICAL: u32 = 1u32;
pub const SYM_INLINE_COMP_STEPIN: u32 = 2u32;
pub const SYM_INLINE_COMP_STEPOUT: u32 = 3u32;
pub const SYM_INLINE_COMP_STEPOVER: u32 = 4u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SYM_LOAD_FLAGS(pub u32);
pub const SLMFLAG_NONE: SYM_LOAD_FLAGS = SYM_LOAD_FLAGS(0u32);
pub const SLMFLAG_VIRTUAL: SYM_LOAD_FLAGS = SYM_LOAD_FLAGS(1u32);
pub const SLMFLAG_ALT_INDEX: SYM_LOAD_FLAGS = SYM_LOAD_FLAGS(2u32);
pub const SLMFLAG_NO_SYMBOLS: SYM_LOAD_FLAGS = SYM_LOAD_FLAGS(4u32);
impl ::core::convert::From<u32> for SYM_LOAD_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SYM_LOAD_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for SYM_LOAD_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SYM_LOAD_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SYM_LOAD_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SYM_LOAD_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SYM_LOAD_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SYM_SRV_STORE_FILE_FLAGS(pub u32);
pub const SYMSTOREOPT_COMPRESS: SYM_SRV_STORE_FILE_FLAGS = SYM_SRV_STORE_FILE_FLAGS(1u32);
pub const SYMSTOREOPT_OVERWRITE: SYM_SRV_STORE_FILE_FLAGS = SYM_SRV_STORE_FILE_FLAGS(2u32);
pub const SYMSTOREOPT_PASS_IF_EXISTS: SYM_SRV_STORE_FILE_FLAGS = SYM_SRV_STORE_FILE_FLAGS(64u32);
pub const SYMSTOREOPT_POINTER: SYM_SRV_STORE_FILE_FLAGS = SYM_SRV_STORE_FILE_FLAGS(8u32);
pub const SYMSTOREOPT_RETURNINDEX: SYM_SRV_STORE_FILE_FLAGS = SYM_SRV_STORE_FILE_FLAGS(4u32);
impl ::core::convert::From<u32> for SYM_SRV_STORE_FILE_FLAGS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SYM_SRV_STORE_FILE_FLAGS {
type Abi = Self;
}
impl ::core::ops::BitOr for SYM_SRV_STORE_FILE_FLAGS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SYM_SRV_STORE_FILE_FLAGS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SYM_SRV_STORE_FILE_FLAGS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SYM_SRV_STORE_FILE_FLAGS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SYM_SRV_STORE_FILE_FLAGS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const SYM_STKWALK_DEFAULT: u32 = 0u32;
pub const SYM_STKWALK_FORCE_FRAMEPTR: u32 = 1u32;
pub const SYM_STKWALK_ZEROEXTEND_PTRS: u32 = 2u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SYM_TYPE(pub i32);
pub const SymNone: SYM_TYPE = SYM_TYPE(0i32);
pub const SymCoff: SYM_TYPE = SYM_TYPE(1i32);
pub const SymCv: SYM_TYPE = SYM_TYPE(2i32);
pub const SymPdb: SYM_TYPE = SYM_TYPE(3i32);
pub const SymExport: SYM_TYPE = SYM_TYPE(4i32);
pub const SymDeferred: SYM_TYPE = SYM_TYPE(5i32);
pub const SymSym: SYM_TYPE = SYM_TYPE(6i32);
pub const SymDia: SYM_TYPE = SYM_TYPE(7i32);
pub const SymVirtual: SYM_TYPE = SYM_TYPE(8i32);
pub const NumSymTypes: SYM_TYPE = SYM_TYPE(9i32);
impl ::core::convert::From<i32> for SYM_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SYM_TYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ScriptChangeKind(pub i32);
pub const ScriptRename: ScriptChangeKind = ScriptChangeKind(0i32);
impl ::core::convert::From<i32> for ScriptChangeKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ScriptChangeKind {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ScriptDebugEvent(pub i32);
pub const ScriptDebugBreakpoint: ScriptDebugEvent = ScriptDebugEvent(0i32);
pub const ScriptDebugStep: ScriptDebugEvent = ScriptDebugEvent(1i32);
pub const ScriptDebugException: ScriptDebugEvent = ScriptDebugEvent(2i32);
pub const ScriptDebugAsyncBreak: ScriptDebugEvent = ScriptDebugEvent(3i32);
impl ::core::convert::From<i32> for ScriptDebugEvent {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ScriptDebugEvent {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ScriptDebugEventFilter(pub i32);
pub const ScriptDebugEventFilterEntry: ScriptDebugEventFilter = ScriptDebugEventFilter(0i32);
pub const ScriptDebugEventFilterException: ScriptDebugEventFilter = ScriptDebugEventFilter(1i32);
pub const ScriptDebugEventFilterUnhandledException: ScriptDebugEventFilter = ScriptDebugEventFilter(2i32);
pub const ScriptDebugEventFilterAbort: ScriptDebugEventFilter = ScriptDebugEventFilter(3i32);
impl ::core::convert::From<i32> for ScriptDebugEventFilter {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ScriptDebugEventFilter {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ScriptDebugEventInformation {
pub DebugEvent: ScriptDebugEvent,
pub EventPosition: ScriptDebugPosition,
pub EventSpanEnd: ScriptDebugPosition,
pub u: ScriptDebugEventInformation_0,
}
impl ScriptDebugEventInformation {}
impl ::core::default::Default for ScriptDebugEventInformation {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for ScriptDebugEventInformation {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for ScriptDebugEventInformation {}
unsafe impl ::windows::core::Abi for ScriptDebugEventInformation {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union ScriptDebugEventInformation_0 {
pub ExceptionInformation: ScriptDebugEventInformation_0_1,
pub BreakpointInformation: ScriptDebugEventInformation_0_0,
}
impl ScriptDebugEventInformation_0 {}
impl ::core::default::Default for ScriptDebugEventInformation_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for ScriptDebugEventInformation_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for ScriptDebugEventInformation_0 {}
unsafe impl ::windows::core::Abi for ScriptDebugEventInformation_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ScriptDebugEventInformation_0_0 {
pub BreakpointId: u64,
}
impl ScriptDebugEventInformation_0_0 {}
impl ::core::default::Default for ScriptDebugEventInformation_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ScriptDebugEventInformation_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_BreakpointInformation_e__Struct").field("BreakpointId", &self.BreakpointId).finish()
}
}
impl ::core::cmp::PartialEq for ScriptDebugEventInformation_0_0 {
fn eq(&self, other: &Self) -> bool {
self.BreakpointId == other.BreakpointId
}
}
impl ::core::cmp::Eq for ScriptDebugEventInformation_0_0 {}
unsafe impl ::windows::core::Abi for ScriptDebugEventInformation_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ScriptDebugEventInformation_0_1 {
pub IsUncaught: bool,
}
impl ScriptDebugEventInformation_0_1 {}
impl ::core::default::Default for ScriptDebugEventInformation_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ScriptDebugEventInformation_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_ExceptionInformation_e__Struct").field("IsUncaught", &self.IsUncaught).finish()
}
}
impl ::core::cmp::PartialEq for ScriptDebugEventInformation_0_1 {
fn eq(&self, other: &Self) -> bool {
self.IsUncaught == other.IsUncaught
}
}
impl ::core::cmp::Eq for ScriptDebugEventInformation_0_1 {}
unsafe impl ::windows::core::Abi for ScriptDebugEventInformation_0_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct ScriptDebugPosition {
pub Line: u32,
pub Column: u32,
}
impl ScriptDebugPosition {}
impl ::core::default::Default for ScriptDebugPosition {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for ScriptDebugPosition {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("ScriptDebugPosition").field("Line", &self.Line).field("Column", &self.Column).finish()
}
}
impl ::core::cmp::PartialEq for ScriptDebugPosition {
fn eq(&self, other: &Self) -> bool {
self.Line == other.Line && self.Column == other.Column
}
}
impl ::core::cmp::Eq for ScriptDebugPosition {}
unsafe impl ::windows::core::Abi for ScriptDebugPosition {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ScriptDebugState(pub i32);
pub const ScriptDebugNoDebugger: ScriptDebugState = ScriptDebugState(0i32);
pub const ScriptDebugNotExecuting: ScriptDebugState = ScriptDebugState(1i32);
pub const ScriptDebugExecuting: ScriptDebugState = ScriptDebugState(2i32);
pub const ScriptDebugBreak: ScriptDebugState = ScriptDebugState(3i32);
impl ::core::convert::From<i32> for ScriptDebugState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ScriptDebugState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct ScriptExecutionKind(pub i32);
pub const ScriptExecutionNormal: ScriptExecutionKind = ScriptExecutionKind(0i32);
pub const ScriptExecutionStepIn: ScriptExecutionKind = ScriptExecutionKind(1i32);
pub const ScriptExecutionStepOut: ScriptExecutionKind = ScriptExecutionKind(2i32);
pub const ScriptExecutionStepOver: ScriptExecutionKind = ScriptExecutionKind(3i32);
impl ::core::convert::From<i32> for ScriptExecutionKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for ScriptExecutionKind {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SearchTreeForFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(rootpath: Param0, inputpathname: Param1, outputpathbuffer: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SearchTreeForFile(rootpath: super::super::super::Foundation::PSTR, inputpathname: super::super::super::Foundation::PSTR, outputpathbuffer: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SearchTreeForFile(rootpath.into_param().abi(), inputpathname.into_param().abi(), ::core::mem::transmute(outputpathbuffer)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SearchTreeForFileW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(rootpath: Param0, inputpathname: Param1, outputpathbuffer: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SearchTreeForFileW(rootpath: super::super::super::Foundation::PWSTR, inputpathname: super::super::super::Foundation::PWSTR, outputpathbuffer: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SearchTreeForFileW(rootpath.into_param().abi(), inputpathname.into_param().abi(), ::core::mem::transmute(outputpathbuffer)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SetCheckUserInterruptShared(lpstartaddress: ::core::option::Option<LPCALL_BACK_USER_INTERRUPT_ROUTINE>) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetCheckUserInterruptShared(lpstartaddress: ::windows::core::RawPtr);
}
::core::mem::transmute(SetCheckUserInterruptShared(::core::mem::transmute(lpstartaddress)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SetErrorMode(umode: THREAD_ERROR_MODE) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetErrorMode(umode: THREAD_ERROR_MODE) -> u32;
}
::core::mem::transmute(SetErrorMode(::core::mem::transmute(umode)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn SetImageConfigInformation(loadedimage: *mut LOADED_IMAGE, imageconfiginformation: *const IMAGE_LOAD_CONFIG_DIRECTORY64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetImageConfigInformation(loadedimage: *mut LOADED_IMAGE, imageconfiginformation: *const IMAGE_LOAD_CONFIG_DIRECTORY64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SetImageConfigInformation(::core::mem::transmute(loadedimage), ::core::mem::transmute(imageconfiginformation)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn SetImageConfigInformation(loadedimage: *mut LOADED_IMAGE, imageconfiginformation: *const IMAGE_LOAD_CONFIG_DIRECTORY32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetImageConfigInformation(loadedimage: *mut LOADED_IMAGE, imageconfiginformation: *const IMAGE_LOAD_CONFIG_DIRECTORY32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SetImageConfigInformation(::core::mem::transmute(loadedimage), ::core::mem::transmute(imageconfiginformation)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SetSymLoadError(error: u32) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetSymLoadError(error: u32);
}
::core::mem::transmute(SetSymLoadError(::core::mem::transmute(error)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn SetThreadContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, lpcontext: *const CONTEXT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetThreadContext(hthread: super::super::super::Foundation::HANDLE, lpcontext: *const CONTEXT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SetThreadContext(hthread.into_param().abi(), ::core::mem::transmute(lpcontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SetThreadErrorMode(dwnewmode: THREAD_ERROR_MODE, lpoldmode: *const THREAD_ERROR_MODE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetThreadErrorMode(dwnewmode: THREAD_ERROR_MODE, lpoldmode: *const THREAD_ERROR_MODE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SetThreadErrorMode(::core::mem::transmute(dwnewmode), ::core::mem::transmute(lpoldmode)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn SetUnhandledExceptionFilter(lptoplevelexceptionfilter: ::core::option::Option<LPTOP_LEVEL_EXCEPTION_FILTER>) -> ::core::option::Option<LPTOP_LEVEL_EXCEPTION_FILTER> {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetUnhandledExceptionFilter(lptoplevelexceptionfilter: ::windows::core::RawPtr) -> ::core::option::Option<LPTOP_LEVEL_EXCEPTION_FILTER>;
}
::core::mem::transmute(SetUnhandledExceptionFilter(::core::mem::transmute(lptoplevelexceptionfilter)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86", target_arch = "x86_64",))]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn SetXStateFeaturesMask(context: *mut CONTEXT, featuremask: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SetXStateFeaturesMask(context: *mut CONTEXT, featuremask: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SetXStateFeaturesMask(::core::mem::transmute(context), ::core::mem::transmute(featuremask)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SignatureComparison(pub i32);
pub const Unrelated: SignatureComparison = SignatureComparison(0i32);
pub const Ambiguous: SignatureComparison = SignatureComparison(1i32);
pub const LessSpecific: SignatureComparison = SignatureComparison(2i32);
pub const MoreSpecific: SignatureComparison = SignatureComparison(3i32);
pub const Identical: SignatureComparison = SignatureComparison(4i32);
impl ::core::convert::From<i32> for SignatureComparison {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SignatureComparison {
type Abi = Self;
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn StackWalk<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(
machinetype: u32,
hprocess: Param1,
hthread: Param2,
stackframe: *mut STACKFRAME,
contextrecord: *mut ::core::ffi::c_void,
readmemoryroutine: ::core::option::Option<PREAD_PROCESS_MEMORY_ROUTINE>,
functiontableaccessroutine: ::core::option::Option<PFUNCTION_TABLE_ACCESS_ROUTINE>,
getmodulebaseroutine: ::core::option::Option<PGET_MODULE_BASE_ROUTINE>,
translateaddress: ::core::option::Option<PTRANSLATE_ADDRESS_ROUTINE>,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn StackWalk(machinetype: u32, hprocess: super::super::super::Foundation::HANDLE, hthread: super::super::super::Foundation::HANDLE, stackframe: *mut STACKFRAME, contextrecord: *mut ::core::ffi::c_void, readmemoryroutine: ::windows::core::RawPtr, functiontableaccessroutine: ::windows::core::RawPtr, getmodulebaseroutine: ::windows::core::RawPtr, translateaddress: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(StackWalk(
::core::mem::transmute(machinetype),
hprocess.into_param().abi(),
hthread.into_param().abi(),
::core::mem::transmute(stackframe),
::core::mem::transmute(contextrecord),
::core::mem::transmute(readmemoryroutine),
::core::mem::transmute(functiontableaccessroutine),
::core::mem::transmute(getmodulebaseroutine),
::core::mem::transmute(translateaddress),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn StackWalk64<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(
machinetype: u32,
hprocess: Param1,
hthread: Param2,
stackframe: *mut STACKFRAME64,
contextrecord: *mut ::core::ffi::c_void,
readmemoryroutine: ::core::option::Option<PREAD_PROCESS_MEMORY_ROUTINE64>,
functiontableaccessroutine: ::core::option::Option<PFUNCTION_TABLE_ACCESS_ROUTINE64>,
getmodulebaseroutine: ::core::option::Option<PGET_MODULE_BASE_ROUTINE64>,
translateaddress: ::core::option::Option<PTRANSLATE_ADDRESS_ROUTINE64>,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn StackWalk64(machinetype: u32, hprocess: super::super::super::Foundation::HANDLE, hthread: super::super::super::Foundation::HANDLE, stackframe: *mut STACKFRAME64, contextrecord: *mut ::core::ffi::c_void, readmemoryroutine: ::windows::core::RawPtr, functiontableaccessroutine: ::windows::core::RawPtr, getmodulebaseroutine: ::windows::core::RawPtr, translateaddress: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(StackWalk64(
::core::mem::transmute(machinetype),
hprocess.into_param().abi(),
hthread.into_param().abi(),
::core::mem::transmute(stackframe),
::core::mem::transmute(contextrecord),
::core::mem::transmute(readmemoryroutine),
::core::mem::transmute(functiontableaccessroutine),
::core::mem::transmute(getmodulebaseroutine),
::core::mem::transmute(translateaddress),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn StackWalkEx<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(
machinetype: u32,
hprocess: Param1,
hthread: Param2,
stackframe: *mut STACKFRAME_EX,
contextrecord: *mut ::core::ffi::c_void,
readmemoryroutine: ::core::option::Option<PREAD_PROCESS_MEMORY_ROUTINE64>,
functiontableaccessroutine: ::core::option::Option<PFUNCTION_TABLE_ACCESS_ROUTINE64>,
getmodulebaseroutine: ::core::option::Option<PGET_MODULE_BASE_ROUTINE64>,
translateaddress: ::core::option::Option<PTRANSLATE_ADDRESS_ROUTINE64>,
flags: u32,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn StackWalkEx(machinetype: u32, hprocess: super::super::super::Foundation::HANDLE, hthread: super::super::super::Foundation::HANDLE, stackframe: *mut STACKFRAME_EX, contextrecord: *mut ::core::ffi::c_void, readmemoryroutine: ::windows::core::RawPtr, functiontableaccessroutine: ::windows::core::RawPtr, getmodulebaseroutine: ::windows::core::RawPtr, translateaddress: ::windows::core::RawPtr, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(StackWalkEx(
::core::mem::transmute(machinetype),
hprocess.into_param().abi(),
hthread.into_param().abi(),
::core::mem::transmute(stackframe),
::core::mem::transmute(contextrecord),
::core::mem::transmute(readmemoryroutine),
::core::mem::transmute(functiontableaccessroutine),
::core::mem::transmute(getmodulebaseroutine),
::core::mem::transmute(translateaddress),
::core::mem::transmute(flags),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddSourceStream<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, streamfile: Param2, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddSourceStream(hprocess: super::super::super::Foundation::HANDLE, base: u64, streamfile: super::super::super::Foundation::PSTR, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymAddSourceStream(hprocess.into_param().abi(), ::core::mem::transmute(base), streamfile.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddSourceStreamA<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, streamfile: Param2, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddSourceStreamA(hprocess: super::super::super::Foundation::HANDLE, base: u64, streamfile: super::super::super::Foundation::PSTR, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymAddSourceStreamA(hprocess.into_param().abi(), ::core::mem::transmute(base), streamfile.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddSourceStreamW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, base: u64, filespec: Param2, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddSourceStreamW(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PWSTR, buffer: *const u8, size: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymAddSourceStreamW(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddSymbol<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, address: u64, size: u32, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddSymbol(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PSTR, address: u64, size: u32, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymAddSymbol(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(size), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddSymbolW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, address: u64, size: u32, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddSymbolW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PWSTR, address: u64, size: u32, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymAddSymbolW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(size), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymAddrIncludeInlineTrace<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymAddrIncludeInlineTrace(hprocess: super::super::super::Foundation::HANDLE, address: u64) -> u32;
}
::core::mem::transmute(SymAddrIncludeInlineTrace(hprocess.into_param().abi(), ::core::mem::transmute(address)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymCleanup<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymCleanup(hprocess: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymCleanup(hprocess.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymCompareInlineTrace<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address1: u64, inlinecontext1: u32, retaddress1: u64, address2: u64, retaddress2: u64) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymCompareInlineTrace(hprocess: super::super::super::Foundation::HANDLE, address1: u64, inlinecontext1: u32, retaddress1: u64, address2: u64, retaddress2: u64) -> u32;
}
::core::mem::transmute(SymCompareInlineTrace(hprocess.into_param().abi(), ::core::mem::transmute(address1), ::core::mem::transmute(inlinecontext1), ::core::mem::transmute(retaddress1), ::core::mem::transmute(address2), ::core::mem::transmute(retaddress2)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymDeleteSymbol<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, address: u64, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymDeleteSymbol(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PSTR, address: u64, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymDeleteSymbol(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymDeleteSymbolW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, address: u64, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymDeleteSymbolW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PWSTR, address: u64, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymDeleteSymbolW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumLines<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, obj: Param2, file: Param3, enumlinescallback: ::core::option::Option<PSYM_ENUMLINES_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumLines(hprocess: super::super::super::Foundation::HANDLE, base: u64, obj: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR, enumlinescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumLines(hprocess.into_param().abi(), ::core::mem::transmute(base), obj.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(enumlinescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumLinesW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, base: u64, obj: Param2, file: Param3, enumlinescallback: ::core::option::Option<PSYM_ENUMLINES_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumLinesW(hprocess: super::super::super::Foundation::HANDLE, base: u64, obj: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR, enumlinescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumLinesW(hprocess.into_param().abi(), ::core::mem::transmute(base), obj.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(enumlinescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumProcesses(enumprocessescallback: ::core::option::Option<PSYM_ENUMPROCESSES_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumProcesses(enumprocessescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumProcesses(::core::mem::transmute(enumprocessescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSourceFileTokens<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, base: u64, callback: ::core::option::Option<PENUMSOURCEFILETOKENSCALLBACK>) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSourceFileTokens(hprocess: super::super::super::Foundation::HANDLE, base: u64, callback: ::windows::core::RawPtr) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSourceFileTokens(hprocess.into_param().abi(), ::core::mem::transmute(base), ::core::mem::transmute(callback)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSourceFiles<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, modbase: u64, mask: Param2, cbsrcfiles: ::core::option::Option<PSYM_ENUMSOURCEFILES_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSourceFiles(hprocess: super::super::super::Foundation::HANDLE, modbase: u64, mask: super::super::super::Foundation::PSTR, cbsrcfiles: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSourceFiles(hprocess.into_param().abi(), ::core::mem::transmute(modbase), mask.into_param().abi(), ::core::mem::transmute(cbsrcfiles), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSourceFilesW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, modbase: u64, mask: Param2, cbsrcfiles: ::core::option::Option<PSYM_ENUMSOURCEFILES_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSourceFilesW(hprocess: super::super::super::Foundation::HANDLE, modbase: u64, mask: super::super::super::Foundation::PWSTR, cbsrcfiles: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSourceFilesW(hprocess.into_param().abi(), ::core::mem::transmute(modbase), mask.into_param().abi(), ::core::mem::transmute(cbsrcfiles), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSourceLines<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
base: u64,
obj: Param2,
file: Param3,
line: u32,
flags: u32,
enumlinescallback: ::core::option::Option<PSYM_ENUMLINES_CALLBACK>,
usercontext: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSourceLines(hprocess: super::super::super::Foundation::HANDLE, base: u64, obj: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR, line: u32, flags: u32, enumlinescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSourceLines(hprocess.into_param().abi(), ::core::mem::transmute(base), obj.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(line), ::core::mem::transmute(flags), ::core::mem::transmute(enumlinescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSourceLinesW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
base: u64,
obj: Param2,
file: Param3,
line: u32,
flags: u32,
enumlinescallback: ::core::option::Option<PSYM_ENUMLINES_CALLBACKW>,
usercontext: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSourceLinesW(hprocess: super::super::super::Foundation::HANDLE, base: u64, obj: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR, line: u32, flags: u32, enumlinescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSourceLinesW(hprocess.into_param().abi(), ::core::mem::transmute(base), obj.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(line), ::core::mem::transmute(flags), ::core::mem::transmute(enumlinescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSym<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSym(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSym(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbols<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbols(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbols(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbolsEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbolsEx(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbolsEx(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext), ::core::mem::transmute(options)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbolsExW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbolsExW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PWSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbolsExW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext), ::core::mem::transmute(options)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbolsForAddr<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbolsForAddr(hprocess: super::super::super::Foundation::HANDLE, address: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbolsForAddr(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbolsForAddrW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbolsForAddrW(hprocess: super::super::super::Foundation::HANDLE, address: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbolsForAddrW(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumSymbolsW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumSymbolsW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PWSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumSymbolsW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumTypes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumTypes(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumTypes(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumTypesByName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumTypesByName(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumTypesByName(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumTypesByNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, mask: Param2, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumTypesByNameW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, mask: super::super::super::Foundation::PWSTR, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumTypesByNameW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), mask.into_param().abi(), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumTypesW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumTypesW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumTypesW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateModules<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enummodulescallback: ::core::option::Option<PSYM_ENUMMODULES_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateModules(hprocess: super::super::super::Foundation::HANDLE, enummodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateModules(hprocess.into_param().abi(), ::core::mem::transmute(enummodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateModules64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enummodulescallback: ::core::option::Option<PSYM_ENUMMODULES_CALLBACK64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateModules64(hprocess: super::super::super::Foundation::HANDLE, enummodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateModules64(hprocess.into_param().abi(), ::core::mem::transmute(enummodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateModulesW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, enummodulescallback: ::core::option::Option<PSYM_ENUMMODULES_CALLBACKW64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateModulesW64(hprocess: super::super::super::Foundation::HANDLE, enummodulescallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateModulesW64(hprocess.into_param().abi(), ::core::mem::transmute(enummodulescallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateSymbols<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u32, enumsymbolscallback: ::core::option::Option<PSYM_ENUMSYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateSymbols(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u32, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateSymbols(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateSymbols64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMSYMBOLS_CALLBACK64>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateSymbols64(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateSymbols64(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateSymbolsW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u32, enumsymbolscallback: ::core::option::Option<PSYM_ENUMSYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateSymbolsW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u32, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateSymbolsW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymEnumerateSymbolsW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMSYMBOLS_CALLBACK64W>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymEnumerateSymbolsW64(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymEnumerateSymbolsW64(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(enumsymbolscallback), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindDebugInfoFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, filename: Param1, debugfilepath: super::super::super::Foundation::PSTR, callback: ::core::option::Option<PFIND_DEBUG_FILE_CALLBACK>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindDebugInfoFile(hprocess: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PSTR, debugfilepath: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(SymFindDebugInfoFile(hprocess.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindDebugInfoFileW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, filename: Param1, debugfilepath: super::super::super::Foundation::PWSTR, callback: ::core::option::Option<PFIND_DEBUG_FILE_CALLBACKW>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindDebugInfoFileW(hprocess: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PWSTR, debugfilepath: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(SymFindDebugInfoFileW(hprocess.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindExecutableImage<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, filename: Param1, imagefilepath: super::super::super::Foundation::PSTR, callback: ::core::option::Option<PFIND_EXE_FILE_CALLBACK>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindExecutableImage(hprocess: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PSTR, imagefilepath: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(SymFindExecutableImage(hprocess.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(imagefilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindExecutableImageW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, filename: Param1, imagefilepath: super::super::super::Foundation::PWSTR, callback: ::core::option::Option<PFIND_EXE_FILE_CALLBACKW>, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindExecutableImageW(hprocess: super::super::super::Foundation::HANDLE, filename: super::super::super::Foundation::PWSTR, imagefilepath: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, callerdata: *const ::core::ffi::c_void) -> super::super::super::Foundation::HANDLE;
}
::core::mem::transmute(SymFindExecutableImageW(hprocess.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(imagefilepath), ::core::mem::transmute(callback), ::core::mem::transmute(callerdata)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindFileInPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
searchpatha: Param1,
filename: Param2,
id: *const ::core::ffi::c_void,
two: u32,
three: u32,
flags: SYM_FIND_ID_OPTION,
foundfile: super::super::super::Foundation::PSTR,
callback: ::core::option::Option<PFINDFILEINPATHCALLBACK>,
context: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindFileInPath(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, id: *const ::core::ffi::c_void, two: u32, three: u32, flags: SYM_FIND_ID_OPTION, foundfile: super::super::super::Foundation::PSTR, callback: ::windows::core::RawPtr, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFindFileInPath(
hprocess.into_param().abi(),
searchpatha.into_param().abi(),
filename.into_param().abi(),
::core::mem::transmute(id),
::core::mem::transmute(two),
::core::mem::transmute(three),
::core::mem::transmute(flags),
::core::mem::transmute(foundfile),
::core::mem::transmute(callback),
::core::mem::transmute(context),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFindFileInPathW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
searchpatha: Param1,
filename: Param2,
id: *const ::core::ffi::c_void,
two: u32,
three: u32,
flags: SYM_FIND_ID_OPTION,
foundfile: super::super::super::Foundation::PWSTR,
callback: ::core::option::Option<PFINDFILEINPATHCALLBACKW>,
context: *const ::core::ffi::c_void,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFindFileInPathW(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PWSTR, filename: super::super::super::Foundation::PWSTR, id: *const ::core::ffi::c_void, two: u32, three: u32, flags: SYM_FIND_ID_OPTION, foundfile: super::super::super::Foundation::PWSTR, callback: ::windows::core::RawPtr, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFindFileInPathW(
hprocess.into_param().abi(),
searchpatha.into_param().abi(),
filename.into_param().abi(),
::core::mem::transmute(id),
::core::mem::transmute(two),
::core::mem::transmute(three),
::core::mem::transmute(flags),
::core::mem::transmute(foundfile),
::core::mem::transmute(callback),
::core::mem::transmute(context),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromAddr<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, displacement: *mut u64, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromAddr(hprocess: super::super::super::Foundation::HANDLE, address: u64, displacement: *mut u64, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromAddr(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(displacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromAddrW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, displacement: *mut u64, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromAddrW(hprocess: super::super::super::Foundation::HANDLE, address: u64, displacement: *mut u64, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromAddrW(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(displacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromIndex<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromIndex(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromIndex(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(index), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromIndexW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromIndexW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromIndexW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(index), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromInlineContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, inlinecontext: u32, displacement: *mut u64, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromInlineContext(hprocess: super::super::super::Foundation::HANDLE, address: u64, inlinecontext: u32, displacement: *mut u64, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromInlineContext(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(displacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromInlineContextW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, inlinecontext: u32, displacement: *mut u64, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromInlineContextW(hprocess: super::super::super::Foundation::HANDLE, address: u64, inlinecontext: u32, displacement: *mut u64, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromInlineContextW(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(displacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, name: Param1, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromName(hprocess: super::super::super::Foundation::HANDLE, name: super::super::super::Foundation::PSTR, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromName(hprocess.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, name: Param1, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromNameW(hprocess: super::super::super::Foundation::HANDLE, name: super::super::super::Foundation::PWSTR, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromNameW(hprocess.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromToken<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, base: u64, token: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromToken(hprocess: super::super::super::Foundation::HANDLE, base: u64, token: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromToken(hprocess.into_param().abi(), ::core::mem::transmute(base), ::core::mem::transmute(token), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFromTokenW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, base: u64, token: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFromTokenW(hprocess: super::super::super::Foundation::HANDLE, base: u64, token: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymFromTokenW(hprocess.into_param().abi(), ::core::mem::transmute(base), ::core::mem::transmute(token), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFunctionTableAccess<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, addrbase: u32) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFunctionTableAccess(hprocess: super::super::super::Foundation::HANDLE, addrbase: u32) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(SymFunctionTableAccess(hprocess.into_param().abi(), ::core::mem::transmute(addrbase)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFunctionTableAccess64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, addrbase: u64) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFunctionTableAccess64(hprocess: super::super::super::Foundation::HANDLE, addrbase: u64) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(SymFunctionTableAccess64(hprocess.into_param().abi(), ::core::mem::transmute(addrbase)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymFunctionTableAccess64AccessRoutines<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, addrbase: u64, readmemoryroutine: ::core::option::Option<PREAD_PROCESS_MEMORY_ROUTINE64>, getmodulebaseroutine: ::core::option::Option<PGET_MODULE_BASE_ROUTINE64>) -> *mut ::core::ffi::c_void {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymFunctionTableAccess64AccessRoutines(hprocess: super::super::super::Foundation::HANDLE, addrbase: u64, readmemoryroutine: ::windows::core::RawPtr, getmodulebaseroutine: ::windows::core::RawPtr) -> *mut ::core::ffi::c_void;
}
::core::mem::transmute(SymFunctionTableAccess64AccessRoutines(hprocess.into_param().abi(), ::core::mem::transmute(addrbase), ::core::mem::transmute(readmemoryroutine), ::core::mem::transmute(getmodulebaseroutine)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetExtendedOption(option: IMAGEHLP_EXTENDED_OPTIONS) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetExtendedOption(option: IMAGEHLP_EXTENDED_OPTIONS) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetExtendedOption(::core::mem::transmute(option)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetFileLineOffsets64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, modulename: Param1, filename: Param2, buffer: *mut u64, bufferlines: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetFileLineOffsets64(hprocess: super::super::super::Foundation::HANDLE, modulename: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, buffer: *mut u64, bufferlines: u32) -> u32;
}
::core::mem::transmute(SymGetFileLineOffsets64(hprocess.into_param().abi(), modulename.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(buffer), ::core::mem::transmute(bufferlines)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetHomeDirectory(r#type: IMAGEHLP_HD_TYPE, dir: super::super::super::Foundation::PSTR, size: usize) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetHomeDirectory(r#type: IMAGEHLP_HD_TYPE, dir: super::super::super::Foundation::PSTR, size: usize) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymGetHomeDirectory(::core::mem::transmute(r#type), ::core::mem::transmute(dir), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetHomeDirectoryW(r#type: IMAGEHLP_HD_TYPE, dir: super::super::super::Foundation::PWSTR, size: usize) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetHomeDirectoryW(r#type: IMAGEHLP_HD_TYPE, dir: super::super::super::Foundation::PWSTR, size: usize) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymGetHomeDirectoryW(::core::mem::transmute(r#type), ::core::mem::transmute(dir), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromAddr<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u32, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromAddr(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u32, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromAddr(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromAddr64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64, pdwdisplacement: *mut u32, line64: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromAddr64(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64, pdwdisplacement: *mut u32, line64: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromAddr64(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(line64)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromAddrW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u64, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromAddrW64(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u64, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromAddrW64(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromInlineContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64, inlinecontext: u32, qwmodulebaseaddress: u64, pdwdisplacement: *mut u32, line64: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromInlineContext(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64, inlinecontext: u32, qwmodulebaseaddress: u64, pdwdisplacement: *mut u32, line64: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromInlineContext(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(qwmodulebaseaddress), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(line64)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromInlineContextW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u64, inlinecontext: u32, qwmodulebaseaddress: u64, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromInlineContextW(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u64, inlinecontext: u32, qwmodulebaseaddress: u64, pdwdisplacement: *mut u32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromInlineContextW(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(inlinecontext), ::core::mem::transmute(qwmodulebaseaddress), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, modulename: Param1, filename: Param2, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromName(hprocess: super::super::super::Foundation::HANDLE, modulename: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromName(hprocess.into_param().abi(), modulename.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(dwlinenumber), ::core::mem::transmute(pldisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromName64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, modulename: Param1, filename: Param2, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromName64(hprocess: super::super::super::Foundation::HANDLE, modulename: super::super::super::Foundation::PSTR, filename: super::super::super::Foundation::PSTR, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromName64(hprocess.into_param().abi(), modulename.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(dwlinenumber), ::core::mem::transmute(pldisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineFromNameW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, modulename: Param1, filename: Param2, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineFromNameW64(hprocess: super::super::super::Foundation::HANDLE, modulename: super::super::super::Foundation::PWSTR, filename: super::super::super::Foundation::PWSTR, dwlinenumber: u32, pldisplacement: *mut i32, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineFromNameW64(hprocess.into_param().abi(), modulename.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(dwlinenumber), ::core::mem::transmute(pldisplacement), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineNext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineNext(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineNext(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineNext64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineNext64(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineNext64(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLineNextW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLineNextW64(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLineNextW64(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLinePrev<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLinePrev(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLinePrev(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLinePrev64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLinePrev64(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLinePrev64(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetLinePrevW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetLinePrevW64(hprocess: super::super::super::Foundation::HANDLE, line: *mut IMAGEHLP_LINEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetLinePrevW64(hprocess.into_param().abi(), ::core::mem::transmute(line)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleBase<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleBase(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u32) -> u32;
}
::core::mem::transmute(SymGetModuleBase(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleBase64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64) -> u64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleBase64(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64) -> u64;
}
::core::mem::transmute(SymGetModuleBase64(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u32, moduleinfo: *mut IMAGEHLP_MODULE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleInfo(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u32, moduleinfo: *mut IMAGEHLP_MODULE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetModuleInfo(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(moduleinfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleInfo64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64, moduleinfo: *mut IMAGEHLP_MODULE64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleInfo64(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64, moduleinfo: *mut IMAGEHLP_MODULE64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetModuleInfo64(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr), ::core::mem::transmute(moduleinfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleInfoW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u32, moduleinfo: *mut IMAGEHLP_MODULEW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleInfoW(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u32, moduleinfo: *mut IMAGEHLP_MODULEW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetModuleInfoW(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(moduleinfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetModuleInfoW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64, moduleinfo: *mut IMAGEHLP_MODULEW64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetModuleInfoW64(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64, moduleinfo: *mut IMAGEHLP_MODULEW64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetModuleInfoW64(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr), ::core::mem::transmute(moduleinfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetOmaps<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, omapto: *mut *mut OMAP, comapto: *mut u64, omapfrom: *mut *mut OMAP, comapfrom: *mut u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetOmaps(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, omapto: *mut *mut OMAP, comapto: *mut u64, omapfrom: *mut *mut OMAP, comapfrom: *mut u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetOmaps(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(omapto), ::core::mem::transmute(comapto), ::core::mem::transmute(omapfrom), ::core::mem::transmute(comapfrom)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SymGetOptions() -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetOptions() -> u32;
}
::core::mem::transmute(SymGetOptions())
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetScope<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetScope(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetScope(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(index), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetScopeW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetScopeW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetScopeW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(index), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSearchPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, searchpatha: super::super::super::Foundation::PSTR, searchpathlength: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSearchPath(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PSTR, searchpathlength: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSearchPath(hprocess.into_param().abi(), ::core::mem::transmute(searchpatha), ::core::mem::transmute(searchpathlength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSearchPathW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, searchpatha: super::super::super::Foundation::PWSTR, searchpathlength: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSearchPathW(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PWSTR, searchpathlength: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSearchPathW(hprocess.into_param().abi(), ::core::mem::transmute(searchpatha), ::core::mem::transmute(searchpathlength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, params: Param2, filespec: Param3, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFile(hprocess: super::super::super::Foundation::HANDLE, base: u64, params: super::super::super::Foundation::PSTR, filespec: super::super::super::Foundation::PSTR, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFile(hprocess.into_param().abi(), ::core::mem::transmute(base), params.into_param().abi(), filespec.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileChecksum<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, filespec: Param2, pchecksumtype: *mut u32, pchecksum: *mut u8, checksumsize: u32, pactualbyteswritten: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileChecksum(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PSTR, pchecksumtype: *mut u32, pchecksum: *mut u8, checksumsize: u32, pactualbyteswritten: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileChecksum(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), ::core::mem::transmute(pchecksumtype), ::core::mem::transmute(pchecksum), ::core::mem::transmute(checksumsize), ::core::mem::transmute(pactualbyteswritten)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileChecksumW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, base: u64, filespec: Param2, pchecksumtype: *mut u32, pchecksum: *mut u8, checksumsize: u32, pactualbyteswritten: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileChecksumW(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PWSTR, pchecksumtype: *mut u32, pchecksum: *mut u8, checksumsize: u32, pactualbyteswritten: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileChecksumW(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), ::core::mem::transmute(pchecksumtype), ::core::mem::transmute(pchecksum), ::core::mem::transmute(checksumsize), ::core::mem::transmute(pactualbyteswritten)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileFromToken<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, params: Param2, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileFromToken(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, params: super::super::super::Foundation::PSTR, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileFromToken(hprocess.into_param().abi(), ::core::mem::transmute(token), params.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileFromTokenByTokenName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, tokenname: Param2, params: Param3, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileFromTokenByTokenName(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, tokenname: super::super::super::Foundation::PSTR, params: super::super::super::Foundation::PSTR, filepath: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileFromTokenByTokenName(hprocess.into_param().abi(), ::core::mem::transmute(token), tokenname.into_param().abi(), params.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileFromTokenByTokenNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, tokenname: Param2, params: Param3, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileFromTokenByTokenNameW(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, tokenname: super::super::super::Foundation::PWSTR, params: super::super::super::Foundation::PWSTR, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileFromTokenByTokenNameW(hprocess.into_param().abi(), ::core::mem::transmute(token), tokenname.into_param().abi(), params.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileFromTokenW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, params: Param2, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileFromTokenW(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, params: super::super::super::Foundation::PWSTR, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileFromTokenW(hprocess.into_param().abi(), ::core::mem::transmute(token), params.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileToken<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, base: u64, filespec: Param2, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileToken(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PSTR, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileToken(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), ::core::mem::transmute(token), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileTokenByTokenName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
base: u64,
filespec: Param2,
tokenname: Param3,
tokenparameters: Param4,
token: *mut *mut ::core::ffi::c_void,
size: *mut u32,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileTokenByTokenName(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PSTR, tokenname: super::super::super::Foundation::PSTR, tokenparameters: super::super::super::Foundation::PSTR, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileTokenByTokenName(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), tokenname.into_param().abi(), tokenparameters.into_param().abi(), ::core::mem::transmute(token), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileTokenByTokenNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
base: u64,
filespec: Param2,
tokenname: Param3,
tokenparameters: Param4,
token: *mut *mut ::core::ffi::c_void,
size: *mut u32,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileTokenByTokenNameW(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PWSTR, tokenname: super::super::super::Foundation::PWSTR, tokenparameters: super::super::super::Foundation::PWSTR, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileTokenByTokenNameW(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), tokenname.into_param().abi(), tokenparameters.into_param().abi(), ::core::mem::transmute(token), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileTokenW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, base: u64, filespec: Param2, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileTokenW(hprocess: super::super::super::Foundation::HANDLE, base: u64, filespec: super::super::super::Foundation::PWSTR, token: *mut *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileTokenW(hprocess.into_param().abi(), ::core::mem::transmute(base), filespec.into_param().abi(), ::core::mem::transmute(token), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceFileW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, base: u64, params: Param2, filespec: Param3, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceFileW(hprocess: super::super::super::Foundation::HANDLE, base: u64, params: super::super::super::Foundation::PWSTR, filespec: super::super::super::Foundation::PWSTR, filepath: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceFileW(hprocess.into_param().abi(), ::core::mem::transmute(base), params.into_param().abi(), filespec.into_param().abi(), ::core::mem::transmute(filepath), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceVarFromToken<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, params: Param2, varname: Param3, value: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceVarFromToken(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, params: super::super::super::Foundation::PSTR, varname: super::super::super::Foundation::PSTR, value: super::super::super::Foundation::PSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceVarFromToken(hprocess.into_param().abi(), ::core::mem::transmute(token), params.into_param().abi(), varname.into_param().abi(), ::core::mem::transmute(value), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSourceVarFromTokenW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, token: *const ::core::ffi::c_void, params: Param2, varname: Param3, value: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSourceVarFromTokenW(hprocess: super::super::super::Foundation::HANDLE, token: *const ::core::ffi::c_void, params: super::super::super::Foundation::PWSTR, varname: super::super::super::Foundation::PWSTR, value: super::super::super::Foundation::PWSTR, size: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSourceVarFromTokenW(hprocess.into_param().abi(), ::core::mem::transmute(token), params.into_param().abi(), varname.into_param().abi(), ::core::mem::transmute(value), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymFromAddr<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, dwaddr: u32, pdwdisplacement: *mut u32, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymFromAddr(hprocess: super::super::super::Foundation::HANDLE, dwaddr: u32, pdwdisplacement: *mut u32, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymFromAddr(hprocess.into_param().abi(), ::core::mem::transmute(dwaddr), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymFromAddr64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, qwaddr: u64, pdwdisplacement: *mut u64, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymFromAddr64(hprocess: super::super::super::Foundation::HANDLE, qwaddr: u64, pdwdisplacement: *mut u64, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymFromAddr64(hprocess.into_param().abi(), ::core::mem::transmute(qwaddr), ::core::mem::transmute(pdwdisplacement), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymFromName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, name: Param1, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymFromName(hprocess: super::super::super::Foundation::HANDLE, name: super::super::super::Foundation::PSTR, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymFromName(hprocess.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymFromName64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, name: Param1, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymFromName64(hprocess: super::super::super::Foundation::HANDLE, name: super::super::super::Foundation::PSTR, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymFromName64(hprocess.into_param().abi(), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymNext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymNext(hprocess: super::super::super::Foundation::HANDLE, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymNext(hprocess.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymNext64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymNext64(hprocess: super::super::super::Foundation::HANDLE, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymNext64(hprocess.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymPrev<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymPrev(hprocess: super::super::super::Foundation::HANDLE, symbol: *mut IMAGEHLP_SYMBOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymPrev(hprocess.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymPrev64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymPrev64(hprocess: super::super::super::Foundation::HANDLE, symbol: *mut IMAGEHLP_SYMBOL64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymPrev64(hprocess.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymbolFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
sympath: Param1,
imagefile: Param2,
r#type: IMAGEHLP_SF_TYPE,
symbolfile: super::super::super::Foundation::PSTR,
csymbolfile: usize,
dbgfile: super::super::super::Foundation::PSTR,
cdbgfile: usize,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymbolFile(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PSTR, imagefile: super::super::super::Foundation::PSTR, r#type: IMAGEHLP_SF_TYPE, symbolfile: super::super::super::Foundation::PSTR, csymbolfile: usize, dbgfile: super::super::super::Foundation::PSTR, cdbgfile: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymbolFile(hprocess.into_param().abi(), sympath.into_param().abi(), imagefile.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(symbolfile), ::core::mem::transmute(csymbolfile), ::core::mem::transmute(dbgfile), ::core::mem::transmute(cdbgfile)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetSymbolFileW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
sympath: Param1,
imagefile: Param2,
r#type: IMAGEHLP_SF_TYPE,
symbolfile: super::super::super::Foundation::PWSTR,
csymbolfile: usize,
dbgfile: super::super::super::Foundation::PWSTR,
cdbgfile: usize,
) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetSymbolFileW(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PWSTR, imagefile: super::super::super::Foundation::PWSTR, r#type: IMAGEHLP_SF_TYPE, symbolfile: super::super::super::Foundation::PWSTR, csymbolfile: usize, dbgfile: super::super::super::Foundation::PWSTR, cdbgfile: usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetSymbolFileW(hprocess.into_param().abi(), sympath.into_param().abi(), imagefile.into_param().abi(), ::core::mem::transmute(r#type), ::core::mem::transmute(symbolfile), ::core::mem::transmute(csymbolfile), ::core::mem::transmute(dbgfile), ::core::mem::transmute(cdbgfile)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetTypeFromName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetTypeFromName(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PSTR, symbol: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetTypeFromName(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetTypeFromNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, name: Param2, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetTypeFromNameW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, name: super::super::super::Foundation::PWSTR, symbol: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetTypeFromNameW(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), name.into_param().abi(), ::core::mem::transmute(symbol)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetTypeInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, modbase: u64, typeid: u32, gettype: IMAGEHLP_SYMBOL_TYPE_INFO, pinfo: *mut ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetTypeInfo(hprocess: super::super::super::Foundation::HANDLE, modbase: u64, typeid: u32, gettype: IMAGEHLP_SYMBOL_TYPE_INFO, pinfo: *mut ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetTypeInfo(hprocess.into_param().abi(), ::core::mem::transmute(modbase), ::core::mem::transmute(typeid), ::core::mem::transmute(gettype), ::core::mem::transmute(pinfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetTypeInfoEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, modbase: u64, params: *mut IMAGEHLP_GET_TYPE_INFO_PARAMS) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetTypeInfoEx(hprocess: super::super::super::Foundation::HANDLE, modbase: u64, params: *mut IMAGEHLP_GET_TYPE_INFO_PARAMS) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetTypeInfoEx(hprocess.into_param().abi(), ::core::mem::transmute(modbase), ::core::mem::transmute(params)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymGetUnwindInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, buffer: *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymGetUnwindInfo(hprocess: super::super::super::Foundation::HANDLE, address: u64, buffer: *mut ::core::ffi::c_void, size: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymGetUnwindInfo(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(buffer), ::core::mem::transmute(size)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymInitialize<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(hprocess: Param0, usersearchpath: Param1, finvadeprocess: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymInitialize(hprocess: super::super::super::Foundation::HANDLE, usersearchpath: super::super::super::Foundation::PSTR, finvadeprocess: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymInitialize(hprocess.into_param().abi(), usersearchpath.into_param().abi(), finvadeprocess.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymInitializeW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(hprocess: Param0, usersearchpath: Param1, finvadeprocess: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymInitializeW(hprocess: super::super::super::Foundation::HANDLE, usersearchpath: super::super::super::Foundation::PWSTR, finvadeprocess: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymInitializeW(hprocess.into_param().abi(), usersearchpath.into_param().abi(), finvadeprocess.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymLoadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, hfile: Param1, imagename: Param2, modulename: Param3, baseofdll: u32, sizeofdll: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymLoadModule(hprocess: super::super::super::Foundation::HANDLE, hfile: super::super::super::Foundation::HANDLE, imagename: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, baseofdll: u32, sizeofdll: u32) -> u32;
}
::core::mem::transmute(SymLoadModule(hprocess.into_param().abi(), hfile.into_param().abi(), imagename.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(sizeofdll)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymLoadModule64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, hfile: Param1, imagename: Param2, modulename: Param3, baseofdll: u64, sizeofdll: u32) -> u64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymLoadModule64(hprocess: super::super::super::Foundation::HANDLE, hfile: super::super::super::Foundation::HANDLE, imagename: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, baseofdll: u64, sizeofdll: u32) -> u64;
}
::core::mem::transmute(SymLoadModule64(hprocess.into_param().abi(), hfile.into_param().abi(), imagename.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(sizeofdll)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymLoadModuleEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
hfile: Param1,
imagename: Param2,
modulename: Param3,
baseofdll: u64,
dllsize: u32,
data: *const MODLOAD_DATA,
flags: SYM_LOAD_FLAGS,
) -> u64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymLoadModuleEx(hprocess: super::super::super::Foundation::HANDLE, hfile: super::super::super::Foundation::HANDLE, imagename: super::super::super::Foundation::PSTR, modulename: super::super::super::Foundation::PSTR, baseofdll: u64, dllsize: u32, data: *const MODLOAD_DATA, flags: SYM_LOAD_FLAGS) -> u64;
}
::core::mem::transmute(SymLoadModuleEx(hprocess.into_param().abi(), hfile.into_param().abi(), imagename.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(dllsize), ::core::mem::transmute(data), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymLoadModuleExW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
hfile: Param1,
imagename: Param2,
modulename: Param3,
baseofdll: u64,
dllsize: u32,
data: *const MODLOAD_DATA,
flags: SYM_LOAD_FLAGS,
) -> u64 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymLoadModuleExW(hprocess: super::super::super::Foundation::HANDLE, hfile: super::super::super::Foundation::HANDLE, imagename: super::super::super::Foundation::PWSTR, modulename: super::super::super::Foundation::PWSTR, baseofdll: u64, dllsize: u32, data: *const MODLOAD_DATA, flags: SYM_LOAD_FLAGS) -> u64;
}
::core::mem::transmute(SymLoadModuleExW(hprocess.into_param().abi(), hfile.into_param().abi(), imagename.into_param().abi(), modulename.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(dllsize), ::core::mem::transmute(data), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymMatchFileName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(filename: Param0, r#match: Param1, filenamestop: *mut super::super::super::Foundation::PSTR, matchstop: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymMatchFileName(filename: super::super::super::Foundation::PSTR, r#match: super::super::super::Foundation::PSTR, filenamestop: *mut super::super::super::Foundation::PSTR, matchstop: *mut super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymMatchFileName(filename.into_param().abi(), r#match.into_param().abi(), ::core::mem::transmute(filenamestop), ::core::mem::transmute(matchstop)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymMatchFileNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(filename: Param0, r#match: Param1, filenamestop: *mut super::super::super::Foundation::PWSTR, matchstop: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymMatchFileNameW(filename: super::super::super::Foundation::PWSTR, r#match: super::super::super::Foundation::PWSTR, filenamestop: *mut super::super::super::Foundation::PWSTR, matchstop: *mut super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymMatchFileNameW(filename.into_param().abi(), r#match.into_param().abi(), ::core::mem::transmute(filenamestop), ::core::mem::transmute(matchstop)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymMatchString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(string: Param0, expression: Param1, fcase: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymMatchString(string: super::super::super::Foundation::PSTR, expression: super::super::super::Foundation::PSTR, fcase: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymMatchString(string.into_param().abi(), expression.into_param().abi(), fcase.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymMatchStringA<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(string: Param0, expression: Param1, fcase: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymMatchStringA(string: super::super::super::Foundation::PSTR, expression: super::super::super::Foundation::PSTR, fcase: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymMatchStringA(string.into_param().abi(), expression.into_param().abi(), fcase.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymMatchStringW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(string: Param0, expression: Param1, fcase: Param2) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymMatchStringW(string: super::super::super::Foundation::PWSTR, expression: super::super::super::Foundation::PWSTR, fcase: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymMatchStringW(string.into_param().abi(), expression.into_param().abi(), fcase.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymNext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, si: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymNext(hprocess: super::super::super::Foundation::HANDLE, si: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymNext(hprocess.into_param().abi(), ::core::mem::transmute(si)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymNextW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, siw: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymNextW(hprocess: super::super::super::Foundation::HANDLE, siw: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymNextW(hprocess.into_param().abi(), ::core::mem::transmute(siw)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymPrev<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, si: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymPrev(hprocess: super::super::super::Foundation::HANDLE, si: *mut SYMBOL_INFO) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymPrev(hprocess.into_param().abi(), ::core::mem::transmute(si)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymPrevW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, siw: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymPrevW(hprocess: super::super::super::Foundation::HANDLE, siw: *mut SYMBOL_INFOW) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymPrevW(hprocess.into_param().abi(), ::core::mem::transmute(siw)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymQueryInlineTrace<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, startaddress: u64, startcontext: u32, startretaddress: u64, curaddress: u64, curcontext: *mut u32, curframeindex: *mut u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymQueryInlineTrace(hprocess: super::super::super::Foundation::HANDLE, startaddress: u64, startcontext: u32, startretaddress: u64, curaddress: u64, curcontext: *mut u32, curframeindex: *mut u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymQueryInlineTrace(hprocess.into_param().abi(), ::core::mem::transmute(startaddress), ::core::mem::transmute(startcontext), ::core::mem::transmute(startretaddress), ::core::mem::transmute(curaddress), ::core::mem::transmute(curcontext), ::core::mem::transmute(curframeindex)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRefreshModuleList<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRefreshModuleList(hprocess: super::super::super::Foundation::HANDLE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRefreshModuleList(hprocess.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRegisterCallback<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, callbackfunction: ::core::option::Option<PSYMBOL_REGISTERED_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRegisterCallback(hprocess: super::super::super::Foundation::HANDLE, callbackfunction: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRegisterCallback(hprocess.into_param().abi(), ::core::mem::transmute(callbackfunction), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRegisterCallback64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, callbackfunction: ::core::option::Option<PSYMBOL_REGISTERED_CALLBACK64>, usercontext: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRegisterCallback64(hprocess: super::super::super::Foundation::HANDLE, callbackfunction: ::windows::core::RawPtr, usercontext: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRegisterCallback64(hprocess.into_param().abi(), ::core::mem::transmute(callbackfunction), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRegisterCallbackW64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, callbackfunction: ::core::option::Option<PSYMBOL_REGISTERED_CALLBACK64>, usercontext: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRegisterCallbackW64(hprocess: super::super::super::Foundation::HANDLE, callbackfunction: ::windows::core::RawPtr, usercontext: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRegisterCallbackW64(hprocess.into_param().abi(), ::core::mem::transmute(callbackfunction), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRegisterFunctionEntryCallback<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, callbackfunction: ::core::option::Option<PSYMBOL_FUNCENTRY_CALLBACK>, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRegisterFunctionEntryCallback(hprocess: super::super::super::Foundation::HANDLE, callbackfunction: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRegisterFunctionEntryCallback(hprocess.into_param().abi(), ::core::mem::transmute(callbackfunction), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymRegisterFunctionEntryCallback64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, callbackfunction: ::core::option::Option<PSYMBOL_FUNCENTRY_CALLBACK64>, usercontext: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymRegisterFunctionEntryCallback64(hprocess: super::super::super::Foundation::HANDLE, callbackfunction: ::windows::core::RawPtr, usercontext: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymRegisterFunctionEntryCallback64(hprocess.into_param().abi(), ::core::mem::transmute(callbackfunction), ::core::mem::transmute(usercontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSearch<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, baseofdll: u64, index: u32, symtag: u32, mask: Param4, address: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACK>, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSearch(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symtag: u32, mask: super::super::super::Foundation::PSTR, address: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSearch(
hprocess.into_param().abi(),
::core::mem::transmute(baseofdll),
::core::mem::transmute(index),
::core::mem::transmute(symtag),
mask.into_param().abi(),
::core::mem::transmute(address),
::core::mem::transmute(enumsymbolscallback),
::core::mem::transmute(usercontext),
::core::mem::transmute(options),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSearchW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, baseofdll: u64, index: u32, symtag: u32, mask: Param4, address: u64, enumsymbolscallback: ::core::option::Option<PSYM_ENUMERATESYMBOLS_CALLBACKW>, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSearchW(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32, symtag: u32, mask: super::super::super::Foundation::PWSTR, address: u64, enumsymbolscallback: ::windows::core::RawPtr, usercontext: *const ::core::ffi::c_void, options: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSearchW(
hprocess.into_param().abi(),
::core::mem::transmute(baseofdll),
::core::mem::transmute(index),
::core::mem::transmute(symtag),
mask.into_param().abi(),
::core::mem::transmute(address),
::core::mem::transmute(enumsymbolscallback),
::core::mem::transmute(usercontext),
::core::mem::transmute(options),
))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, stackframe: *const IMAGEHLP_STACK_FRAME, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetContext(hprocess: super::super::super::Foundation::HANDLE, stackframe: *const IMAGEHLP_STACK_FRAME, context: *const ::core::ffi::c_void) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetContext(hprocess.into_param().abi(), ::core::mem::transmute(stackframe), ::core::mem::transmute(context)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetExtendedOption<'a, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::BOOL>>(option: IMAGEHLP_EXTENDED_OPTIONS, value: Param1) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetExtendedOption(option: IMAGEHLP_EXTENDED_OPTIONS, value: super::super::super::Foundation::BOOL) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetExtendedOption(::core::mem::transmute(option), value.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetHomeDirectory<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, dir: Param1) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetHomeDirectory(hprocess: super::super::super::Foundation::HANDLE, dir: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymSetHomeDirectory(hprocess.into_param().abi(), dir.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetHomeDirectoryW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, dir: Param1) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetHomeDirectoryW(hprocess: super::super::super::Foundation::HANDLE, dir: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymSetHomeDirectoryW(hprocess.into_param().abi(), dir.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[inline]
pub unsafe fn SymSetOptions(symoptions: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetOptions(symoptions: u32) -> u32;
}
::core::mem::transmute(SymSetOptions(::core::mem::transmute(symoptions)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetParentWindow<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HWND>>(hwnd: Param0) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetParentWindow(hwnd: super::super::super::Foundation::HWND) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetParentWindow(hwnd.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetScopeFromAddr<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetScopeFromAddr(hprocess: super::super::super::Foundation::HANDLE, address: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetScopeFromAddr(hprocess.into_param().abi(), ::core::mem::transmute(address)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetScopeFromIndex<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64, index: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetScopeFromIndex(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64, index: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetScopeFromIndex(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll), ::core::mem::transmute(index)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetScopeFromInlineContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, address: u64, inlinecontext: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetScopeFromInlineContext(hprocess: super::super::super::Foundation::HANDLE, address: u64, inlinecontext: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetScopeFromInlineContext(hprocess.into_param().abi(), ::core::mem::transmute(address), ::core::mem::transmute(inlinecontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetSearchPath<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, searchpatha: Param1) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetSearchPath(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetSearchPath(hprocess.into_param().abi(), searchpatha.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSetSearchPathW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, searchpatha: Param1) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSetSearchPathW(hprocess: super::super::super::Foundation::HANDLE, searchpatha: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSetSearchPathW(hprocess.into_param().abi(), searchpatha.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvDeltaName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(
hprocess: Param0,
sympath: Param1,
r#type: Param2,
file1: Param3,
file2: Param4,
) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvDeltaName(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PSTR, r#type: super::super::super::Foundation::PSTR, file1: super::super::super::Foundation::PSTR, file2: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymSrvDeltaName(hprocess.into_param().abi(), sympath.into_param().abi(), r#type.into_param().abi(), file1.into_param().abi(), file2.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvDeltaNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param4: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(
hprocess: Param0,
sympath: Param1,
r#type: Param2,
file1: Param3,
file2: Param4,
) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvDeltaNameW(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PWSTR, r#type: super::super::super::Foundation::PWSTR, file1: super::super::super::Foundation::PWSTR, file2: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymSrvDeltaNameW(hprocess.into_param().abi(), sympath.into_param().abi(), r#type.into_param().abi(), file1.into_param().abi(), file2.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexInfo<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(file: Param0, info: *mut SYMSRV_INDEX_INFO, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexInfo(file: super::super::super::Foundation::PSTR, info: *mut SYMSRV_INDEX_INFO, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexInfo(file.into_param().abi(), ::core::mem::transmute(info), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexInfoW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(file: Param0, info: *mut SYMSRV_INDEX_INFOW, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexInfoW(file: super::super::super::Foundation::PWSTR, info: *mut SYMSRV_INDEX_INFOW, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexInfoW(file.into_param().abi(), ::core::mem::transmute(info), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexString<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, srvpath: Param1, file: Param2, index: super::super::super::Foundation::PSTR, size: usize, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexString(hprocess: super::super::super::Foundation::HANDLE, srvpath: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR, index: super::super::super::Foundation::PSTR, size: usize, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexString(hprocess.into_param().abi(), srvpath.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(index), ::core::mem::transmute(size), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexStringW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, srvpath: Param1, file: Param2, index: super::super::super::Foundation::PWSTR, size: usize, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexStringW(hprocess: super::super::super::Foundation::HANDLE, srvpath: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR, index: super::super::super::Foundation::PWSTR, size: usize, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexStringW(hprocess.into_param().abi(), srvpath.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(index), ::core::mem::transmute(size), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(file: Param0, id: *mut ::windows::core::GUID, val1: *mut u32, val2: *mut u32, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexes(file: super::super::super::Foundation::PSTR, id: *mut ::windows::core::GUID, val1: *mut u32, val2: *mut u32, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexes(file.into_param().abi(), ::core::mem::transmute(id), ::core::mem::transmute(val1), ::core::mem::transmute(val2), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetFileIndexesW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(file: Param0, id: *mut ::windows::core::GUID, val1: *mut u32, val2: *mut u32, flags: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetFileIndexesW(file: super::super::super::Foundation::PWSTR, id: *mut ::windows::core::GUID, val1: *mut u32, val2: *mut u32, flags: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvGetFileIndexesW(file.into_param().abi(), ::core::mem::transmute(id), ::core::mem::transmute(val1), ::core::mem::transmute(val2), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetSupplement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, sympath: Param1, node: Param2, file: Param3) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetSupplement(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PSTR, node: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymSrvGetSupplement(hprocess.into_param().abi(), sympath.into_param().abi(), node.into_param().abi(), file.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvGetSupplementW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, sympath: Param1, node: Param2, file: Param3) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvGetSupplementW(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PWSTR, node: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymSrvGetSupplementW(hprocess.into_param().abi(), sympath.into_param().abi(), node.into_param().abi(), file.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvIsStore<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, path: Param1) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvIsStore(hprocess: super::super::super::Foundation::HANDLE, path: super::super::super::Foundation::PSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvIsStore(hprocess.into_param().abi(), path.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvIsStoreW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, path: Param1) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvIsStoreW(hprocess: super::super::super::Foundation::HANDLE, path: super::super::super::Foundation::PWSTR) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymSrvIsStoreW(hprocess.into_param().abi(), path.into_param().abi()))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvStoreFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, srvpath: Param1, file: Param2, flags: SYM_SRV_STORE_FILE_FLAGS) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvStoreFile(hprocess: super::super::super::Foundation::HANDLE, srvpath: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR, flags: SYM_SRV_STORE_FILE_FLAGS) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymSrvStoreFile(hprocess.into_param().abi(), srvpath.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvStoreFileW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, srvpath: Param1, file: Param2, flags: SYM_SRV_STORE_FILE_FLAGS) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvStoreFileW(hprocess: super::super::super::Foundation::HANDLE, srvpath: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR, flags: SYM_SRV_STORE_FILE_FLAGS) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymSrvStoreFileW(hprocess.into_param().abi(), srvpath.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvStoreSupplement<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(hprocess: Param0, srvpath: Param1, node: Param2, file: Param3, flags: u32) -> super::super::super::Foundation::PSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvStoreSupplement(hprocess: super::super::super::Foundation::HANDLE, srvpath: super::super::super::Foundation::PSTR, node: super::super::super::Foundation::PSTR, file: super::super::super::Foundation::PSTR, flags: u32) -> super::super::super::Foundation::PSTR;
}
::core::mem::transmute(SymSrvStoreSupplement(hprocess.into_param().abi(), srvpath.into_param().abi(), node.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymSrvStoreSupplementW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(hprocess: Param0, sympath: Param1, node: Param2, file: Param3, flags: u32) -> super::super::super::Foundation::PWSTR {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymSrvStoreSupplementW(hprocess: super::super::super::Foundation::HANDLE, sympath: super::super::super::Foundation::PWSTR, node: super::super::super::Foundation::PWSTR, file: super::super::super::Foundation::PWSTR, flags: u32) -> super::super::super::Foundation::PWSTR;
}
::core::mem::transmute(SymSrvStoreSupplementW(hprocess.into_param().abi(), sympath.into_param().abi(), node.into_param().abi(), file.into_param().abi(), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymUnDName(sym: *const IMAGEHLP_SYMBOL, undecname: super::super::super::Foundation::PSTR, undecnamelength: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymUnDName(sym: *const IMAGEHLP_SYMBOL, undecname: super::super::super::Foundation::PSTR, undecnamelength: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymUnDName(::core::mem::transmute(sym), ::core::mem::transmute(undecname), ::core::mem::transmute(undecnamelength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymUnDName64(sym: *const IMAGEHLP_SYMBOL64, undecname: super::super::super::Foundation::PSTR, undecnamelength: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymUnDName64(sym: *const IMAGEHLP_SYMBOL64, undecname: super::super::super::Foundation::PSTR, undecnamelength: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymUnDName64(::core::mem::transmute(sym), ::core::mem::transmute(undecname), ::core::mem::transmute(undecnamelength)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(any(target_arch = "x86",))]
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymUnloadModule<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymUnloadModule(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymUnloadModule(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn SymUnloadModule64<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, baseofdll: u64) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn SymUnloadModule64(hprocess: super::super::super::Foundation::HANDLE, baseofdll: u64) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(SymUnloadModule64(hprocess.into_param().abi(), ::core::mem::transmute(baseofdll)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SymbolKind(pub i32);
pub const Symbol: SymbolKind = SymbolKind(0i32);
pub const SymbolModule: SymbolKind = SymbolKind(1i32);
pub const SymbolType: SymbolKind = SymbolKind(2i32);
pub const SymbolField: SymbolKind = SymbolKind(3i32);
pub const SymbolConstant: SymbolKind = SymbolKind(4i32);
pub const SymbolData: SymbolKind = SymbolKind(5i32);
pub const SymbolBaseClass: SymbolKind = SymbolKind(6i32);
pub const SymbolPublic: SymbolKind = SymbolKind(7i32);
pub const SymbolFunction: SymbolKind = SymbolKind(8i32);
impl ::core::convert::From<i32> for SymbolKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SymbolKind {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SymbolSearchOptions(pub i32);
pub const SymbolSearchNone: SymbolSearchOptions = SymbolSearchOptions(0i32);
pub const SymbolSearchCompletion: SymbolSearchOptions = SymbolSearchOptions(1i32);
pub const SymbolSearchCaseInsensitive: SymbolSearchOptions = SymbolSearchOptions(2i32);
impl ::core::convert::From<i32> for SymbolSearchOptions {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SymbolSearchOptions {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct TEXT_DOCUMENT_ARRAY {
pub dwCount: u32,
pub Members: *mut ::core::option::Option<IDebugDocumentText>,
}
impl TEXT_DOCUMENT_ARRAY {}
impl ::core::default::Default for TEXT_DOCUMENT_ARRAY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for TEXT_DOCUMENT_ARRAY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("TEXT_DOCUMENT_ARRAY").field("dwCount", &self.dwCount).field("Members", &self.Members).finish()
}
}
impl ::core::cmp::PartialEq for TEXT_DOCUMENT_ARRAY {
fn eq(&self, other: &Self) -> bool {
self.dwCount == other.dwCount && self.Members == other.Members
}
}
impl ::core::cmp::Eq for TEXT_DOCUMENT_ARRAY {}
unsafe impl ::windows::core::Abi for TEXT_DOCUMENT_ARRAY {
type Abi = Self;
}
pub const TEXT_DOC_ATTR_READONLY: u32 = 1u32;
pub const TEXT_DOC_ATTR_TYPE_PRIMARY: u32 = 2u32;
pub const TEXT_DOC_ATTR_TYPE_SCRIPT: u32 = 8u32;
pub const TEXT_DOC_ATTR_TYPE_WORKER: u32 = 4u32;
pub const THREAD_BLOCKED: u32 = 4u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct THREAD_ERROR_MODE(pub u32);
pub const SEM_ALL_ERRORS: THREAD_ERROR_MODE = THREAD_ERROR_MODE(0u32);
pub const SEM_FAILCRITICALERRORS: THREAD_ERROR_MODE = THREAD_ERROR_MODE(1u32);
pub const SEM_NOGPFAULTERRORBOX: THREAD_ERROR_MODE = THREAD_ERROR_MODE(2u32);
pub const SEM_NOOPENFILEERRORBOX: THREAD_ERROR_MODE = THREAD_ERROR_MODE(32768u32);
pub const SEM_NOALIGNMENTFAULTEXCEPT: THREAD_ERROR_MODE = THREAD_ERROR_MODE(4u32);
impl ::core::convert::From<u32> for THREAD_ERROR_MODE {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for THREAD_ERROR_MODE {
type Abi = Self;
}
impl ::core::ops::BitOr for THREAD_ERROR_MODE {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for THREAD_ERROR_MODE {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for THREAD_ERROR_MODE {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for THREAD_ERROR_MODE {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for THREAD_ERROR_MODE {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const THREAD_OUT_OF_CONTEXT: u32 = 8u32;
pub const THREAD_STATE_RUNNING: u32 = 1u32;
pub const THREAD_STATE_SUSPENDED: u32 = 2u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct THREAD_WRITE_FLAGS(pub i32);
pub const ThreadWriteThread: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(1i32);
pub const ThreadWriteStack: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(2i32);
pub const ThreadWriteContext: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(4i32);
pub const ThreadWriteBackingStore: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(8i32);
pub const ThreadWriteInstructionWindow: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(16i32);
pub const ThreadWriteThreadData: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(32i32);
pub const ThreadWriteThreadInfo: THREAD_WRITE_FLAGS = THREAD_WRITE_FLAGS(64i32);
impl ::core::convert::From<i32> for THREAD_WRITE_FLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for THREAD_WRITE_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct TI_FINDCHILDREN_PARAMS {
pub Count: u32,
pub Start: u32,
pub ChildId: [u32; 1],
}
impl TI_FINDCHILDREN_PARAMS {}
impl ::core::default::Default for TI_FINDCHILDREN_PARAMS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for TI_FINDCHILDREN_PARAMS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("TI_FINDCHILDREN_PARAMS").field("Count", &self.Count).field("Start", &self.Start).field("ChildId", &self.ChildId).finish()
}
}
impl ::core::cmp::PartialEq for TI_FINDCHILDREN_PARAMS {
fn eq(&self, other: &Self) -> bool {
self.Count == other.Count && self.Start == other.Start && self.ChildId == other.ChildId
}
}
impl ::core::cmp::Eq for TI_FINDCHILDREN_PARAMS {}
unsafe impl ::windows::core::Abi for TI_FINDCHILDREN_PARAMS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct TRANSLATE_VIRTUAL_TO_PHYSICAL {
pub Virtual: u64,
pub Physical: u64,
}
impl TRANSLATE_VIRTUAL_TO_PHYSICAL {}
impl ::core::default::Default for TRANSLATE_VIRTUAL_TO_PHYSICAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for TRANSLATE_VIRTUAL_TO_PHYSICAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("TRANSLATE_VIRTUAL_TO_PHYSICAL").field("Virtual", &self.Virtual).field("Physical", &self.Physical).finish()
}
}
impl ::core::cmp::PartialEq for TRANSLATE_VIRTUAL_TO_PHYSICAL {
fn eq(&self, other: &Self) -> bool {
self.Virtual == other.Virtual && self.Physical == other.Physical
}
}
impl ::core::cmp::Eq for TRANSLATE_VIRTUAL_TO_PHYSICAL {}
unsafe impl ::windows::core::Abi for TRANSLATE_VIRTUAL_TO_PHYSICAL {
type Abi = Self;
}
#[inline]
pub unsafe fn TerminateProcessOnMemoryExhaustion(failedallocationsize: usize) {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn TerminateProcessOnMemoryExhaustion(failedallocationsize: usize);
}
::core::mem::transmute(TerminateProcessOnMemoryExhaustion(::core::mem::transmute(failedallocationsize)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn TouchFileTimes<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(filehandle: Param0, psystemtime: *const super::super::super::Foundation::SYSTEMTIME) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn TouchFileTimes(filehandle: super::super::super::Foundation::HANDLE, psystemtime: *const super::super::super::Foundation::SYSTEMTIME) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(TouchFileTimes(filehandle.into_param().abi(), ::core::mem::transmute(psystemtime)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct TypeKind(pub i32);
pub const TypeUDT: TypeKind = TypeKind(0i32);
pub const TypePointer: TypeKind = TypeKind(1i32);
pub const TypeMemberPointer: TypeKind = TypeKind(2i32);
pub const TypeArray: TypeKind = TypeKind(3i32);
pub const TypeFunction: TypeKind = TypeKind(4i32);
pub const TypeTypedef: TypeKind = TypeKind(5i32);
pub const TypeEnum: TypeKind = TypeKind(6i32);
pub const TypeIntrinsic: TypeKind = TypeKind(7i32);
pub const TypeExtendedArray: TypeKind = TypeKind(8i32);
impl ::core::convert::From<i32> for TypeKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for TypeKind {
type Abi = Self;
}
pub const UNAVAILABLE_ERROR: u32 = 12u32;
pub const UNDNAME_32_BIT_DECODE: u32 = 2048u32;
pub const UNDNAME_COMPLETE: u32 = 0u32;
pub const UNDNAME_NAME_ONLY: u32 = 4096u32;
pub const UNDNAME_NO_ACCESS_SPECIFIERS: u32 = 128u32;
pub const UNDNAME_NO_ALLOCATION_LANGUAGE: u32 = 16u32;
pub const UNDNAME_NO_ALLOCATION_MODEL: u32 = 8u32;
pub const UNDNAME_NO_ARGUMENTS: u32 = 8192u32;
pub const UNDNAME_NO_CV_THISTYPE: u32 = 64u32;
pub const UNDNAME_NO_FUNCTION_RETURNS: u32 = 4u32;
pub const UNDNAME_NO_LEADING_UNDERSCORES: u32 = 1u32;
pub const UNDNAME_NO_MEMBER_TYPE: u32 = 512u32;
pub const UNDNAME_NO_MS_KEYWORDS: u32 = 2u32;
pub const UNDNAME_NO_MS_THISTYPE: u32 = 32u32;
pub const UNDNAME_NO_RETURN_UDT_MODEL: u32 = 1024u32;
pub const UNDNAME_NO_SPECIAL_SYMS: u32 = 16384u32;
pub const UNDNAME_NO_THISTYPE: u32 = 96u32;
pub const UNDNAME_NO_THROW_SIGNATURES: u32 = 256u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct UNLOAD_DLL_DEBUG_INFO {
pub lpBaseOfDll: *mut ::core::ffi::c_void,
}
impl UNLOAD_DLL_DEBUG_INFO {}
impl ::core::default::Default for UNLOAD_DLL_DEBUG_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for UNLOAD_DLL_DEBUG_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("UNLOAD_DLL_DEBUG_INFO").field("lpBaseOfDll", &self.lpBaseOfDll).finish()
}
}
impl ::core::cmp::PartialEq for UNLOAD_DLL_DEBUG_INFO {
fn eq(&self, other: &Self) -> bool {
self.lpBaseOfDll == other.lpBaseOfDll
}
}
impl ::core::cmp::Eq for UNLOAD_DLL_DEBUG_INFO {}
unsafe impl ::windows::core::Abi for UNLOAD_DLL_DEBUG_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
pub struct UNWIND_HISTORY_TABLE {
pub Count: u32,
pub LocalHint: u8,
pub GlobalHint: u8,
pub Search: u8,
pub Once: u8,
pub LowAddress: usize,
pub HighAddress: usize,
pub Entry: [UNWIND_HISTORY_TABLE_ENTRY; 12],
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl UNWIND_HISTORY_TABLE {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::default::Default for UNWIND_HISTORY_TABLE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::fmt::Debug for UNWIND_HISTORY_TABLE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("UNWIND_HISTORY_TABLE")
.field("Count", &self.Count)
.field("LocalHint", &self.LocalHint)
.field("GlobalHint", &self.GlobalHint)
.field("Search", &self.Search)
.field("Once", &self.Once)
.field("LowAddress", &self.LowAddress)
.field("HighAddress", &self.HighAddress)
.field("Entry", &self.Entry)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for UNWIND_HISTORY_TABLE {
fn eq(&self, other: &Self) -> bool {
self.Count == other.Count && self.LocalHint == other.LocalHint && self.GlobalHint == other.GlobalHint && self.Search == other.Search && self.Once == other.Once && self.LowAddress == other.LowAddress && self.HighAddress == other.HighAddress && self.Entry == other.Entry
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::Eq for UNWIND_HISTORY_TABLE {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for UNWIND_HISTORY_TABLE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "aarch64",))]
pub struct UNWIND_HISTORY_TABLE_ENTRY {
pub ImageBase: usize,
pub FunctionEntry: *mut IMAGE_ARM64_RUNTIME_FUNCTION_ENTRY,
}
#[cfg(any(target_arch = "aarch64",))]
impl UNWIND_HISTORY_TABLE_ENTRY {}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::default::Default for UNWIND_HISTORY_TABLE_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::fmt::Debug for UNWIND_HISTORY_TABLE_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("UNWIND_HISTORY_TABLE_ENTRY").field("ImageBase", &self.ImageBase).field("FunctionEntry", &self.FunctionEntry).finish()
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for UNWIND_HISTORY_TABLE_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.ImageBase == other.ImageBase && self.FunctionEntry == other.FunctionEntry
}
}
#[cfg(any(target_arch = "aarch64",))]
impl ::core::cmp::Eq for UNWIND_HISTORY_TABLE_ENTRY {}
#[cfg(any(target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for UNWIND_HISTORY_TABLE_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64",))]
pub struct UNWIND_HISTORY_TABLE_ENTRY {
pub ImageBase: usize,
pub FunctionEntry: *mut IMAGE_RUNTIME_FUNCTION_ENTRY,
}
#[cfg(any(target_arch = "x86_64",))]
impl UNWIND_HISTORY_TABLE_ENTRY {}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::default::Default for UNWIND_HISTORY_TABLE_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::fmt::Debug for UNWIND_HISTORY_TABLE_ENTRY {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("UNWIND_HISTORY_TABLE_ENTRY").field("ImageBase", &self.ImageBase).field("FunctionEntry", &self.FunctionEntry).finish()
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::PartialEq for UNWIND_HISTORY_TABLE_ENTRY {
fn eq(&self, other: &Self) -> bool {
self.ImageBase == other.ImageBase && self.FunctionEntry == other.FunctionEntry
}
}
#[cfg(any(target_arch = "x86_64",))]
impl ::core::cmp::Eq for UNWIND_HISTORY_TABLE_ENTRY {}
#[cfg(any(target_arch = "x86_64",))]
unsafe impl ::windows::core::Abi for UNWIND_HISTORY_TABLE_ENTRY {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn UnDecorateSymbolName<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(name: Param0, outputstring: super::super::super::Foundation::PSTR, maxstringlength: u32, flags: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UnDecorateSymbolName(name: super::super::super::Foundation::PSTR, outputstring: super::super::super::Foundation::PSTR, maxstringlength: u32, flags: u32) -> u32;
}
::core::mem::transmute(UnDecorateSymbolName(name.into_param().abi(), ::core::mem::transmute(outputstring), ::core::mem::transmute(maxstringlength), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn UnDecorateSymbolNameW<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PWSTR>>(name: Param0, outputstring: super::super::super::Foundation::PWSTR, maxstringlength: u32, flags: u32) -> u32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UnDecorateSymbolNameW(name: super::super::super::Foundation::PWSTR, outputstring: super::super::super::Foundation::PWSTR, maxstringlength: u32, flags: u32) -> u32;
}
::core::mem::transmute(UnDecorateSymbolNameW(name.into_param().abi(), ::core::mem::transmute(outputstring), ::core::mem::transmute(maxstringlength), ::core::mem::transmute(flags)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn UnMapAndLoad(loadedimage: *mut LOADED_IMAGE) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UnMapAndLoad(loadedimage: *mut LOADED_IMAGE) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(UnMapAndLoad(::core::mem::transmute(loadedimage)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
#[inline]
pub unsafe fn UnhandledExceptionFilter(exceptioninfo: *const EXCEPTION_POINTERS) -> i32 {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UnhandledExceptionFilter(exceptioninfo: *const EXCEPTION_POINTERS) -> i32;
}
::core::mem::transmute(UnhandledExceptionFilter(::core::mem::transmute(exceptioninfo)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn UpdateDebugInfoFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(imagefilename: Param0, symbolpath: Param1, debugfilepath: super::super::super::Foundation::PSTR, ntheaders: *const IMAGE_NT_HEADERS32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UpdateDebugInfoFile(imagefilename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, debugfilepath: super::super::super::Foundation::PSTR, ntheaders: *const IMAGE_NT_HEADERS32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(UpdateDebugInfoFile(imagefilename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(ntheaders)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn UpdateDebugInfoFileEx<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>, Param1: ::windows::core::IntoParam<'a, super::super::super::Foundation::PSTR>>(imagefilename: Param0, symbolpath: Param1, debugfilepath: super::super::super::Foundation::PSTR, ntheaders: *const IMAGE_NT_HEADERS32, oldchecksum: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn UpdateDebugInfoFileEx(imagefilename: super::super::super::Foundation::PSTR, symbolpath: super::super::super::Foundation::PSTR, debugfilepath: super::super::super::Foundation::PSTR, ntheaders: *const IMAGE_NT_HEADERS32, oldchecksum: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(UpdateDebugInfoFileEx(imagefilename.into_param().abi(), symbolpath.into_param().abi(), ::core::mem::transmute(debugfilepath), ::core::mem::transmute(ntheaders), ::core::mem::transmute(oldchecksum)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct VER_PLATFORM(pub u32);
pub const VER_PLATFORM_WIN32s: VER_PLATFORM = VER_PLATFORM(0u32);
pub const VER_PLATFORM_WIN32_WINDOWS: VER_PLATFORM = VER_PLATFORM(1u32);
pub const VER_PLATFORM_WIN32_NT: VER_PLATFORM = VER_PLATFORM(2u32);
impl ::core::convert::From<u32> for VER_PLATFORM {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for VER_PLATFORM {
type Abi = Self;
}
impl ::core::ops::BitOr for VER_PLATFORM {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for VER_PLATFORM {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for VER_PLATFORM {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for VER_PLATFORM {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for VER_PLATFORM {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct VIRTUAL_TO_PHYSICAL {
pub Status: u32,
pub Size: u32,
pub PdeAddress: u64,
pub Virtual: u64,
pub Physical: u64,
}
impl VIRTUAL_TO_PHYSICAL {}
impl ::core::default::Default for VIRTUAL_TO_PHYSICAL {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for VIRTUAL_TO_PHYSICAL {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("VIRTUAL_TO_PHYSICAL").field("Status", &self.Status).field("Size", &self.Size).field("PdeAddress", &self.PdeAddress).field("Virtual", &self.Virtual).field("Physical", &self.Physical).finish()
}
}
impl ::core::cmp::PartialEq for VIRTUAL_TO_PHYSICAL {
fn eq(&self, other: &Self) -> bool {
self.Status == other.Status && self.Size == other.Size && self.PdeAddress == other.PdeAddress && self.Virtual == other.Virtual && self.Physical == other.Physical
}
}
impl ::core::cmp::Eq for VIRTUAL_TO_PHYSICAL {}
unsafe impl ::windows::core::Abi for VIRTUAL_TO_PHYSICAL {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct VarArgsKind(pub i32);
pub const VarArgsNone: VarArgsKind = VarArgsKind(0i32);
pub const VarArgsCStyle: VarArgsKind = VarArgsKind(1i32);
impl ::core::convert::From<i32> for VarArgsKind {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for VarArgsKind {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WAITCHAIN_NODE_INFO {
pub ObjectType: WCT_OBJECT_TYPE,
pub ObjectStatus: WCT_OBJECT_STATUS,
pub Anonymous: WAITCHAIN_NODE_INFO_0,
}
#[cfg(feature = "Win32_Foundation")]
impl WAITCHAIN_NODE_INFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WAITCHAIN_NODE_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WAITCHAIN_NODE_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WAITCHAIN_NODE_INFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WAITCHAIN_NODE_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union WAITCHAIN_NODE_INFO_0 {
pub LockObject: WAITCHAIN_NODE_INFO_0_0,
pub ThreadObject: WAITCHAIN_NODE_INFO_0_1,
}
#[cfg(feature = "Win32_Foundation")]
impl WAITCHAIN_NODE_INFO_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WAITCHAIN_NODE_INFO_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WAITCHAIN_NODE_INFO_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WAITCHAIN_NODE_INFO_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WAITCHAIN_NODE_INFO_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WAITCHAIN_NODE_INFO_0_0 {
pub ObjectName: [u16; 128],
pub Timeout: i64,
pub Alertable: super::super::super::Foundation::BOOL,
}
#[cfg(feature = "Win32_Foundation")]
impl WAITCHAIN_NODE_INFO_0_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WAITCHAIN_NODE_INFO_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for WAITCHAIN_NODE_INFO_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_LockObject_e__Struct").field("ObjectName", &self.ObjectName).field("Timeout", &self.Timeout).field("Alertable", &self.Alertable).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WAITCHAIN_NODE_INFO_0_0 {
fn eq(&self, other: &Self) -> bool {
self.ObjectName == other.ObjectName && self.Timeout == other.Timeout && self.Alertable == other.Alertable
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WAITCHAIN_NODE_INFO_0_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WAITCHAIN_NODE_INFO_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WAITCHAIN_NODE_INFO_0_1 {
pub ProcessId: u32,
pub ThreadId: u32,
pub WaitTime: u32,
pub ContextSwitches: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl WAITCHAIN_NODE_INFO_0_1 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WAITCHAIN_NODE_INFO_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for WAITCHAIN_NODE_INFO_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_ThreadObject_e__Struct").field("ProcessId", &self.ProcessId).field("ThreadId", &self.ThreadId).field("WaitTime", &self.WaitTime).field("ContextSwitches", &self.ContextSwitches).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WAITCHAIN_NODE_INFO_0_1 {
fn eq(&self, other: &Self) -> bool {
self.ProcessId == other.ProcessId && self.ThreadId == other.ThreadId && self.WaitTime == other.WaitTime && self.ContextSwitches == other.ContextSwitches
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WAITCHAIN_NODE_INFO_0_1 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WAITCHAIN_NODE_INFO_0_1 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WAIT_CHAIN_THREAD_OPTIONS(pub u32);
pub const WCT_OUT_OF_PROC_COM_FLAG: WAIT_CHAIN_THREAD_OPTIONS = WAIT_CHAIN_THREAD_OPTIONS(2u32);
pub const WCT_OUT_OF_PROC_CS_FLAG: WAIT_CHAIN_THREAD_OPTIONS = WAIT_CHAIN_THREAD_OPTIONS(4u32);
pub const WCT_OUT_OF_PROC_FLAG: WAIT_CHAIN_THREAD_OPTIONS = WAIT_CHAIN_THREAD_OPTIONS(1u32);
impl ::core::convert::From<u32> for WAIT_CHAIN_THREAD_OPTIONS {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WAIT_CHAIN_THREAD_OPTIONS {
type Abi = Self;
}
impl ::core::ops::BitOr for WAIT_CHAIN_THREAD_OPTIONS {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for WAIT_CHAIN_THREAD_OPTIONS {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for WAIT_CHAIN_THREAD_OPTIONS {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for WAIT_CHAIN_THREAD_OPTIONS {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for WAIT_CHAIN_THREAD_OPTIONS {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
pub const WCT_MAX_NODE_COUNT: u32 = 16u32;
pub const WCT_NETWORK_IO_FLAG: u32 = 8u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WCT_OBJECT_STATUS(pub i32);
pub const WctStatusNoAccess: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(1i32);
pub const WctStatusRunning: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(2i32);
pub const WctStatusBlocked: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(3i32);
pub const WctStatusPidOnly: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(4i32);
pub const WctStatusPidOnlyRpcss: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(5i32);
pub const WctStatusOwned: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(6i32);
pub const WctStatusNotOwned: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(7i32);
pub const WctStatusAbandoned: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(8i32);
pub const WctStatusUnknown: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(9i32);
pub const WctStatusError: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(10i32);
pub const WctStatusMax: WCT_OBJECT_STATUS = WCT_OBJECT_STATUS(11i32);
impl ::core::convert::From<i32> for WCT_OBJECT_STATUS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WCT_OBJECT_STATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WCT_OBJECT_TYPE(pub i32);
pub const WctCriticalSectionType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(1i32);
pub const WctSendMessageType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(2i32);
pub const WctMutexType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(3i32);
pub const WctAlpcType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(4i32);
pub const WctComType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(5i32);
pub const WctThreadWaitType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(6i32);
pub const WctProcessWaitType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(7i32);
pub const WctThreadType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(8i32);
pub const WctComActivationType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(9i32);
pub const WctUnknownType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(10i32);
pub const WctSocketIoType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(11i32);
pub const WctSmbIoType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(12i32);
pub const WctMaxType: WCT_OBJECT_TYPE = WCT_OBJECT_TYPE(13i32);
impl ::core::convert::From<i32> for WCT_OBJECT_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WCT_OBJECT_TYPE {
type Abi = Self;
}
pub const WCT_OBJNAME_LENGTH: u32 = 128u32;
pub const WDBGEXTS_ADDRESS_DEFAULT: u32 = 0u32;
pub const WDBGEXTS_ADDRESS_RESERVED0: u32 = 2147483648u32;
pub const WDBGEXTS_ADDRESS_SEG16: u32 = 1u32;
pub const WDBGEXTS_ADDRESS_SEG32: u32 = 2u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WDBGEXTS_CLR_DATA_INTERFACE {
pub Iid: *mut ::windows::core::GUID,
pub Iface: *mut ::core::ffi::c_void,
}
impl WDBGEXTS_CLR_DATA_INTERFACE {}
impl ::core::default::Default for WDBGEXTS_CLR_DATA_INTERFACE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WDBGEXTS_CLR_DATA_INTERFACE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WDBGEXTS_CLR_DATA_INTERFACE").field("Iid", &self.Iid).field("Iface", &self.Iface).finish()
}
}
impl ::core::cmp::PartialEq for WDBGEXTS_CLR_DATA_INTERFACE {
fn eq(&self, other: &Self) -> bool {
self.Iid == other.Iid && self.Iface == other.Iface
}
}
impl ::core::cmp::Eq for WDBGEXTS_CLR_DATA_INTERFACE {}
unsafe impl ::windows::core::Abi for WDBGEXTS_CLR_DATA_INTERFACE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WDBGEXTS_DISASSEMBLE_BUFFER {
pub InOffset: u64,
pub OutOffset: u64,
pub AddrFlags: u32,
pub FormatFlags: u32,
pub DataBufferBytes: u32,
pub DisasmBufferChars: u32,
pub DataBuffer: *mut ::core::ffi::c_void,
pub DisasmBuffer: super::super::super::Foundation::PWSTR,
pub Reserved0: [u64; 3],
}
#[cfg(feature = "Win32_Foundation")]
impl WDBGEXTS_DISASSEMBLE_BUFFER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WDBGEXTS_DISASSEMBLE_BUFFER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for WDBGEXTS_DISASSEMBLE_BUFFER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WDBGEXTS_DISASSEMBLE_BUFFER")
.field("InOffset", &self.InOffset)
.field("OutOffset", &self.OutOffset)
.field("AddrFlags", &self.AddrFlags)
.field("FormatFlags", &self.FormatFlags)
.field("DataBufferBytes", &self.DataBufferBytes)
.field("DisasmBufferChars", &self.DisasmBufferChars)
.field("DataBuffer", &self.DataBuffer)
.field("DisasmBuffer", &self.DisasmBuffer)
.field("Reserved0", &self.Reserved0)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WDBGEXTS_DISASSEMBLE_BUFFER {
fn eq(&self, other: &Self) -> bool {
self.InOffset == other.InOffset && self.OutOffset == other.OutOffset && self.AddrFlags == other.AddrFlags && self.FormatFlags == other.FormatFlags && self.DataBufferBytes == other.DataBufferBytes && self.DisasmBufferChars == other.DisasmBufferChars && self.DataBuffer == other.DataBuffer && self.DisasmBuffer == other.DisasmBuffer && self.Reserved0 == other.Reserved0
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WDBGEXTS_DISASSEMBLE_BUFFER {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WDBGEXTS_DISASSEMBLE_BUFFER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WDBGEXTS_MODULE_IN_RANGE {
pub Start: u64,
pub End: u64,
pub FoundModBase: u64,
pub FoundModSize: u32,
}
impl WDBGEXTS_MODULE_IN_RANGE {}
impl ::core::default::Default for WDBGEXTS_MODULE_IN_RANGE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WDBGEXTS_MODULE_IN_RANGE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WDBGEXTS_MODULE_IN_RANGE").field("Start", &self.Start).field("End", &self.End).field("FoundModBase", &self.FoundModBase).field("FoundModSize", &self.FoundModSize).finish()
}
}
impl ::core::cmp::PartialEq for WDBGEXTS_MODULE_IN_RANGE {
fn eq(&self, other: &Self) -> bool {
self.Start == other.Start && self.End == other.End && self.FoundModBase == other.FoundModBase && self.FoundModSize == other.FoundModSize
}
}
impl ::core::cmp::Eq for WDBGEXTS_MODULE_IN_RANGE {}
unsafe impl ::windows::core::Abi for WDBGEXTS_MODULE_IN_RANGE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WDBGEXTS_QUERY_INTERFACE {
pub Iid: *mut ::windows::core::GUID,
pub Iface: *mut ::core::ffi::c_void,
}
impl WDBGEXTS_QUERY_INTERFACE {}
impl ::core::default::Default for WDBGEXTS_QUERY_INTERFACE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WDBGEXTS_QUERY_INTERFACE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WDBGEXTS_QUERY_INTERFACE").field("Iid", &self.Iid).field("Iface", &self.Iface).finish()
}
}
impl ::core::cmp::PartialEq for WDBGEXTS_QUERY_INTERFACE {
fn eq(&self, other: &Self) -> bool {
self.Iid == other.Iid && self.Iface == other.Iface
}
}
impl ::core::cmp::Eq for WDBGEXTS_QUERY_INTERFACE {}
unsafe impl ::windows::core::Abi for WDBGEXTS_QUERY_INTERFACE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WDBGEXTS_THREAD_OS_INFO {
pub ThreadId: u32,
pub ExitStatus: u32,
pub PriorityClass: u32,
pub Priority: u32,
pub CreateTime: u64,
pub ExitTime: u64,
pub KernelTime: u64,
pub UserTime: u64,
pub StartOffset: u64,
pub Affinity: u64,
}
impl WDBGEXTS_THREAD_OS_INFO {}
impl ::core::default::Default for WDBGEXTS_THREAD_OS_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WDBGEXTS_THREAD_OS_INFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WDBGEXTS_THREAD_OS_INFO")
.field("ThreadId", &self.ThreadId)
.field("ExitStatus", &self.ExitStatus)
.field("PriorityClass", &self.PriorityClass)
.field("Priority", &self.Priority)
.field("CreateTime", &self.CreateTime)
.field("ExitTime", &self.ExitTime)
.field("KernelTime", &self.KernelTime)
.field("UserTime", &self.UserTime)
.field("StartOffset", &self.StartOffset)
.field("Affinity", &self.Affinity)
.finish()
}
}
impl ::core::cmp::PartialEq for WDBGEXTS_THREAD_OS_INFO {
fn eq(&self, other: &Self) -> bool {
self.ThreadId == other.ThreadId && self.ExitStatus == other.ExitStatus && self.PriorityClass == other.PriorityClass && self.Priority == other.Priority && self.CreateTime == other.CreateTime && self.ExitTime == other.ExitTime && self.KernelTime == other.KernelTime && self.UserTime == other.UserTime && self.StartOffset == other.StartOffset && self.Affinity == other.Affinity
}
}
impl ::core::cmp::Eq for WDBGEXTS_THREAD_OS_INFO {}
unsafe impl ::windows::core::Abi for WDBGEXTS_THREAD_OS_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_AER_BRIDGE_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
pub Reserved: u8,
pub BusNumber: u32,
pub Slot: WHEA_PCI_SLOT_NUMBER,
pub DeviceControl: u16,
pub Flags: AER_BRIDGE_DESCRIPTOR_FLAGS,
pub UncorrectableErrorMask: u32,
pub UncorrectableErrorSeverity: u32,
pub CorrectableErrorMask: u32,
pub AdvancedCapsAndControl: u32,
pub SecondaryUncorrectableErrorMask: u32,
pub SecondaryUncorrectableErrorSev: u32,
pub SecondaryCapsAndControl: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_AER_BRIDGE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_AER_BRIDGE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_AER_BRIDGE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_AER_BRIDGE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_AER_BRIDGE_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_AER_ENDPOINT_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
pub Reserved: u8,
pub BusNumber: u32,
pub Slot: WHEA_PCI_SLOT_NUMBER,
pub DeviceControl: u16,
pub Flags: AER_ENDPOINT_DESCRIPTOR_FLAGS,
pub UncorrectableErrorMask: u32,
pub UncorrectableErrorSeverity: u32,
pub CorrectableErrorMask: u32,
pub AdvancedCapsAndControl: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_AER_ENDPOINT_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_AER_ENDPOINT_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_AER_ENDPOINT_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_AER_ENDPOINT_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_AER_ENDPOINT_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_AER_ROOTPORT_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
pub Reserved: u8,
pub BusNumber: u32,
pub Slot: WHEA_PCI_SLOT_NUMBER,
pub DeviceControl: u16,
pub Flags: AER_ROOTPORT_DESCRIPTOR_FLAGS,
pub UncorrectableErrorMask: u32,
pub UncorrectableErrorSeverity: u32,
pub CorrectableErrorMask: u32,
pub AdvancedCapsAndControl: u32,
pub RootErrorCommand: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_AER_ROOTPORT_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_AER_ROOTPORT_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_AER_ROOTPORT_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_AER_ROOTPORT_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_AER_ROOTPORT_DESCRIPTOR {
type Abi = Self;
}
pub const WHEA_BAD_PAGE_LIST_LOCATION: u32 = 15u32;
pub const WHEA_BAD_PAGE_LIST_MAX_SIZE: u32 = 14u32;
pub const WHEA_CMCI_THRESHOLD_COUNT: u32 = 10u32;
pub const WHEA_CMCI_THRESHOLD_POLL_COUNT: u32 = 12u32;
pub const WHEA_CMCI_THRESHOLD_TIME: u32 = 11u32;
pub const WHEA_DEVICE_DRIVER_BUFFER_SET_MAX: u32 = 1u32;
pub const WHEA_DEVICE_DRIVER_BUFFER_SET_MIN: u32 = 1u32;
pub const WHEA_DEVICE_DRIVER_BUFFER_SET_V1: u32 = 1u32;
pub const WHEA_DEVICE_DRIVER_CONFIG_MAX: u32 = 2u32;
pub const WHEA_DEVICE_DRIVER_CONFIG_MIN: u32 = 1u32;
pub const WHEA_DEVICE_DRIVER_CONFIG_V1: u32 = 1u32;
pub const WHEA_DEVICE_DRIVER_CONFIG_V2: u32 = 2u32;
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_DEVICE_DRIVER_DESCRIPTOR {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_DEVICE_DRIVER_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
pub Reserved: u8,
pub SourceGuid: ::windows::core::GUID,
pub LogTag: u16,
pub Reserved2: u16,
pub PacketLength: u32,
pub PacketCount: u32,
pub PacketBuffer: *mut u8,
pub Config: WHEA_ERROR_SOURCE_CONFIGURATION_DD,
pub CreatorId: ::windows::core::GUID,
pub PartitionId: ::windows::core::GUID,
pub MaxSectionDataLength: u32,
pub MaxSectionsPerRecord: u32,
pub PacketStateBuffer: *mut u8,
pub OpenHandles: i32,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_DEVICE_DRIVER_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_DEVICE_DRIVER_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_DEVICE_DRIVER_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_DEVICE_DRIVER_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_DEVICE_DRIVER_DESCRIPTOR {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const WHEA_DISABLE_DUMMY_WRITE: u32 = 6u32;
pub const WHEA_DISABLE_OFFLINE: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_DRIVER_BUFFER_SET {
pub Version: u32,
pub Data: *mut u8,
pub DataSize: u32,
pub SectionTypeGuid: *mut ::windows::core::GUID,
pub SectionFriendlyName: *mut u8,
pub Flags: *mut u8,
}
impl WHEA_DRIVER_BUFFER_SET {}
impl ::core::default::Default for WHEA_DRIVER_BUFFER_SET {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_DRIVER_BUFFER_SET {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_DRIVER_BUFFER_SET {}
unsafe impl ::windows::core::Abi for WHEA_DRIVER_BUFFER_SET {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_ERROR_SOURCE_CONFIGURATION_DD {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_ERROR_SOURCE_CONFIGURATION_DD {
pub Initialize: ::core::option::Option<WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER>,
pub Uninitialize: ::core::option::Option<WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER>,
pub Correct: ::core::option::Option<WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER>,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_ERROR_SOURCE_CONFIGURATION_DD {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_ERROR_SOURCE_CONFIGURATION_DD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_ERROR_SOURCE_CONFIGURATION_DD {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_ERROR_SOURCE_CONFIGURATION_DD {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_CONFIGURATION_DD {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {
pub Version: u32,
pub SourceGuid: ::windows::core::GUID,
pub LogTag: u16,
pub Reserved: [u8; 6],
pub Initialize: ::core::option::Option<WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER>,
pub Uninitialize: ::core::option::Option<WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER>,
pub MaxSectionDataLength: u32,
pub MaxSectionsPerReport: u32,
pub CreatorId: ::windows::core::GUID,
pub PartitionId: ::windows::core::GUID,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {
pub Version: u32,
pub SourceGuid: ::windows::core::GUID,
pub LogTag: u16,
pub Reserved: [u8; 6],
pub Initialize: ::core::option::Option<WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER>,
pub Uninitialize: ::core::option::Option<WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER>,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_CONFIGURATION_DEVICE_DRIVER_V1 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
pub type WHEA_ERROR_SOURCE_CORRECT_DEVICE_DRIVER = unsafe extern "system" fn(errorsourcedesc: *mut ::core::ffi::c_void, maximumsectionlength: *mut u32) -> super::super::super::Foundation::NTSTATUS;
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_ERROR_SOURCE_DESCRIPTOR {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_ERROR_SOURCE_DESCRIPTOR {
pub Length: u32,
pub Version: u32,
pub Type: WHEA_ERROR_SOURCE_TYPE,
pub State: WHEA_ERROR_SOURCE_STATE,
pub MaxRawDataLength: u32,
pub NumRecordsToPreallocate: u32,
pub MaxSectionsPerRecord: u32,
pub ErrorSourceId: u32,
pub PlatformErrorSourceId: u32,
pub Flags: u32,
pub Info: WHEA_ERROR_SOURCE_DESCRIPTOR_0,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_ERROR_SOURCE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_ERROR_SOURCE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_ERROR_SOURCE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_ERROR_SOURCE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_DESCRIPTOR {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::clone::Clone for WHEA_ERROR_SOURCE_DESCRIPTOR_0 {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub union WHEA_ERROR_SOURCE_DESCRIPTOR_0 {
pub XpfMceDescriptor: WHEA_XPF_MCE_DESCRIPTOR,
pub XpfCmcDescriptor: WHEA_XPF_CMC_DESCRIPTOR,
pub XpfNmiDescriptor: WHEA_XPF_NMI_DESCRIPTOR,
pub IpfMcaDescriptor: WHEA_IPF_MCA_DESCRIPTOR,
pub IpfCmcDescriptor: WHEA_IPF_CMC_DESCRIPTOR,
pub IpfCpeDescriptor: WHEA_IPF_CPE_DESCRIPTOR,
pub AerRootportDescriptor: WHEA_AER_ROOTPORT_DESCRIPTOR,
pub AerEndpointDescriptor: WHEA_AER_ENDPOINT_DESCRIPTOR,
pub AerBridgeDescriptor: WHEA_AER_BRIDGE_DESCRIPTOR,
pub GenErrDescriptor: WHEA_GENERIC_ERROR_DESCRIPTOR,
pub GenErrDescriptorV2: WHEA_GENERIC_ERROR_DESCRIPTOR_V2,
pub DeviceDriverDescriptor: ::core::mem::ManuallyDrop<WHEA_DEVICE_DRIVER_DESCRIPTOR>,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_ERROR_SOURCE_DESCRIPTOR_0 {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_ERROR_SOURCE_DESCRIPTOR_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_ERROR_SOURCE_DESCRIPTOR_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_ERROR_SOURCE_DESCRIPTOR_0 {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_DESCRIPTOR_0 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_AERBRIDGE: u32 = 8u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_AERENDPOINT: u32 = 7u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_AERROOTPORT: u32 = 6u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_GENERIC: u32 = 9u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_GENERIC_V2: u32 = 10u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_IPFCMC: u32 = 4u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_IPFCPE: u32 = 5u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_IPFMCA: u32 = 3u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_XPFCMC: u32 = 1u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_XPFMCE: u32 = 0u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_TYPE_XPFNMI: u32 = 2u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_VERSION_10: u32 = 10u32;
pub const WHEA_ERROR_SOURCE_DESCRIPTOR_VERSION_11: u32 = 11u32;
pub const WHEA_ERROR_SOURCE_FLAG_DEFAULTSOURCE: u32 = 2147483648u32;
pub const WHEA_ERROR_SOURCE_FLAG_FIRMWAREFIRST: u32 = 1u32;
pub const WHEA_ERROR_SOURCE_FLAG_GHES_ASSIST: u32 = 4u32;
pub const WHEA_ERROR_SOURCE_FLAG_GLOBAL: u32 = 2u32;
#[cfg(feature = "Win32_Foundation")]
pub type WHEA_ERROR_SOURCE_INITIALIZE_DEVICE_DRIVER = unsafe extern "system" fn(context: *mut ::core::ffi::c_void, errorsourceid: u32) -> super::super::super::Foundation::NTSTATUS;
pub const WHEA_ERROR_SOURCE_INVALID_RELATED_SOURCE: u32 = 65535u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WHEA_ERROR_SOURCE_STATE(pub i32);
pub const WheaErrSrcStateStopped: WHEA_ERROR_SOURCE_STATE = WHEA_ERROR_SOURCE_STATE(1i32);
pub const WheaErrSrcStateStarted: WHEA_ERROR_SOURCE_STATE = WHEA_ERROR_SOURCE_STATE(2i32);
pub const WheaErrSrcStateRemoved: WHEA_ERROR_SOURCE_STATE = WHEA_ERROR_SOURCE_STATE(3i32);
pub const WheaErrSrcStateRemovePending: WHEA_ERROR_SOURCE_STATE = WHEA_ERROR_SOURCE_STATE(4i32);
impl ::core::convert::From<i32> for WHEA_ERROR_SOURCE_STATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_STATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct WHEA_ERROR_SOURCE_TYPE(pub i32);
pub const WheaErrSrcTypeMCE: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(0i32);
pub const WheaErrSrcTypeCMC: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(1i32);
pub const WheaErrSrcTypeCPE: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(2i32);
pub const WheaErrSrcTypeNMI: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(3i32);
pub const WheaErrSrcTypePCIe: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(4i32);
pub const WheaErrSrcTypeGeneric: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(5i32);
pub const WheaErrSrcTypeINIT: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(6i32);
pub const WheaErrSrcTypeBOOT: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(7i32);
pub const WheaErrSrcTypeSCIGeneric: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(8i32);
pub const WheaErrSrcTypeIPFMCA: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(9i32);
pub const WheaErrSrcTypeIPFCMC: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(10i32);
pub const WheaErrSrcTypeIPFCPE: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(11i32);
pub const WheaErrSrcTypeGenericV2: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(12i32);
pub const WheaErrSrcTypeSCIGenericV2: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(13i32);
pub const WheaErrSrcTypeBMC: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(14i32);
pub const WheaErrSrcTypePMEM: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(15i32);
pub const WheaErrSrcTypeDeviceDriver: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(16i32);
pub const WheaErrSrcTypeMax: WHEA_ERROR_SOURCE_TYPE = WHEA_ERROR_SOURCE_TYPE(17i32);
impl ::core::convert::From<i32> for WHEA_ERROR_SOURCE_TYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for WHEA_ERROR_SOURCE_TYPE {
type Abi = Self;
}
pub type WHEA_ERROR_SOURCE_UNINITIALIZE_DEVICE_DRIVER = unsafe extern "system" fn(context: *mut ::core::ffi::c_void);
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_GENERIC_ERROR_DESCRIPTOR {
pub Type: u16,
pub Reserved: u8,
pub Enabled: u8,
pub ErrStatusBlockLength: u32,
pub RelatedErrorSourceId: u32,
pub ErrStatusAddressSpaceID: u8,
pub ErrStatusAddressBitWidth: u8,
pub ErrStatusAddressBitOffset: u8,
pub ErrStatusAddressAccessSize: u8,
pub ErrStatusAddress: i64,
pub Notify: WHEA_NOTIFICATION_DESCRIPTOR,
}
impl WHEA_GENERIC_ERROR_DESCRIPTOR {}
impl ::core::default::Default for WHEA_GENERIC_ERROR_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_GENERIC_ERROR_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_GENERIC_ERROR_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for WHEA_GENERIC_ERROR_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {
pub Type: u16,
pub Reserved: u8,
pub Enabled: u8,
pub ErrStatusBlockLength: u32,
pub RelatedErrorSourceId: u32,
pub ErrStatusAddressSpaceID: u8,
pub ErrStatusAddressBitWidth: u8,
pub ErrStatusAddressBitOffset: u8,
pub ErrStatusAddressAccessSize: u8,
pub ErrStatusAddress: i64,
pub Notify: WHEA_NOTIFICATION_DESCRIPTOR,
pub ReadAckAddressSpaceID: u8,
pub ReadAckAddressBitWidth: u8,
pub ReadAckAddressBitOffset: u8,
pub ReadAckAddressAccessSize: u8,
pub ReadAckAddress: i64,
pub ReadAckPreserveMask: u64,
pub ReadAckWriteMask: u64,
}
impl WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {}
impl ::core::default::Default for WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {}
unsafe impl ::windows::core::Abi for WHEA_GENERIC_ERROR_DESCRIPTOR_V2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_IPF_CMC_DESCRIPTOR {
pub Type: u16,
pub Enabled: u8,
pub Reserved: u8,
}
impl WHEA_IPF_CMC_DESCRIPTOR {}
impl ::core::default::Default for WHEA_IPF_CMC_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_IPF_CMC_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_IPF_CMC_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for WHEA_IPF_CMC_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_IPF_CPE_DESCRIPTOR {
pub Type: u16,
pub Enabled: u8,
pub Reserved: u8,
}
impl WHEA_IPF_CPE_DESCRIPTOR {}
impl ::core::default::Default for WHEA_IPF_CPE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_IPF_CPE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_IPF_CPE_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for WHEA_IPF_CPE_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_IPF_MCA_DESCRIPTOR {
pub Type: u16,
pub Enabled: u8,
pub Reserved: u8,
}
impl WHEA_IPF_MCA_DESCRIPTOR {}
impl ::core::default::Default for WHEA_IPF_MCA_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_IPF_MCA_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_IPF_MCA_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for WHEA_IPF_MCA_DESCRIPTOR {
type Abi = Self;
}
pub const WHEA_MAX_MC_BANKS: u32 = 32u32;
pub const WHEA_MEM_PERSISTOFFLINE: u32 = 1u32;
pub const WHEA_MEM_PFA_DISABLE: u32 = 2u32;
pub const WHEA_MEM_PFA_PAGECOUNT: u32 = 3u32;
pub const WHEA_MEM_PFA_THRESHOLD: u32 = 4u32;
pub const WHEA_MEM_PFA_TIMEOUT: u32 = 5u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WHEA_NOTIFICATION_DESCRIPTOR {
pub Type: u8,
pub Length: u8,
pub Flags: WHEA_NOTIFICATION_FLAGS,
pub u: WHEA_NOTIFICATION_DESCRIPTOR_0,
}
impl WHEA_NOTIFICATION_DESCRIPTOR {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union WHEA_NOTIFICATION_DESCRIPTOR_0 {
pub Polled: WHEA_NOTIFICATION_DESCRIPTOR_0_4,
pub Interrupt: WHEA_NOTIFICATION_DESCRIPTOR_0_1,
pub LocalInterrupt: WHEA_NOTIFICATION_DESCRIPTOR_0_2,
pub Sci: WHEA_NOTIFICATION_DESCRIPTOR_0_5,
pub Nmi: WHEA_NOTIFICATION_DESCRIPTOR_0_3,
pub Sea: WHEA_NOTIFICATION_DESCRIPTOR_0_6,
pub Sei: WHEA_NOTIFICATION_DESCRIPTOR_0_7,
pub Gsiv: WHEA_NOTIFICATION_DESCRIPTOR_0_0,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_0 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_0 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_0 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_1 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_1 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_1 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_1 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_1 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_2 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_2 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_2 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_2 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_2 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_2 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_3 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_3 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_3 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_3 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_3 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_3 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_4 {
pub PollInterval: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_4 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_4 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_4 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_4 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_4 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_5 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_5 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_5 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_5 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_5 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_5 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_6 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_6 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_6 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_6 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_6 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_6 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_DESCRIPTOR_0_7 {
pub PollInterval: u32,
pub Vector: u32,
pub SwitchToPollingThreshold: u32,
pub SwitchToPollingWindow: u32,
pub ErrorThreshold: u32,
pub ErrorThresholdWindow: u32,
}
impl WHEA_NOTIFICATION_DESCRIPTOR_0_7 {}
impl ::core::default::Default for WHEA_NOTIFICATION_DESCRIPTOR_0_7 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_DESCRIPTOR_0_7 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_DESCRIPTOR_0_7 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_DESCRIPTOR_0_7 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union WHEA_NOTIFICATION_FLAGS {
pub Anonymous: WHEA_NOTIFICATION_FLAGS_0,
pub AsUSHORT: u16,
}
impl WHEA_NOTIFICATION_FLAGS {}
impl ::core::default::Default for WHEA_NOTIFICATION_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_FLAGS {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_NOTIFICATION_FLAGS_0 {
pub _bitfield: u16,
}
impl WHEA_NOTIFICATION_FLAGS_0 {}
impl ::core::default::Default for WHEA_NOTIFICATION_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_NOTIFICATION_FLAGS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_NOTIFICATION_FLAGS_0 {}
unsafe impl ::windows::core::Abi for WHEA_NOTIFICATION_FLAGS_0 {
type Abi = Self;
}
pub const WHEA_NOTIFICATION_TYPE_ARMV8_SEA: u32 = 8u32;
pub const WHEA_NOTIFICATION_TYPE_ARMV8_SEI: u32 = 9u32;
pub const WHEA_NOTIFICATION_TYPE_CMCI: u32 = 5u32;
pub const WHEA_NOTIFICATION_TYPE_EXTERNALINTERRUPT: u32 = 1u32;
pub const WHEA_NOTIFICATION_TYPE_EXTERNALINTERRUPT_GSIV: u32 = 10u32;
pub const WHEA_NOTIFICATION_TYPE_GPIO_SIGNAL: u32 = 7u32;
pub const WHEA_NOTIFICATION_TYPE_LOCALINTERRUPT: u32 = 2u32;
pub const WHEA_NOTIFICATION_TYPE_MCE: u32 = 6u32;
pub const WHEA_NOTIFICATION_TYPE_NMI: u32 = 4u32;
pub const WHEA_NOTIFICATION_TYPE_POLLED: u32 = 0u32;
pub const WHEA_NOTIFICATION_TYPE_SCI: u32 = 3u32;
pub const WHEA_NOTIFICATION_TYPE_SDEI: u32 = 11u32;
pub const WHEA_NOTIFY_ALL_OFFLINES: u32 = 16u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WHEA_PCI_SLOT_NUMBER {
pub u: WHEA_PCI_SLOT_NUMBER_0,
}
impl WHEA_PCI_SLOT_NUMBER {}
impl ::core::default::Default for WHEA_PCI_SLOT_NUMBER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_PCI_SLOT_NUMBER {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_PCI_SLOT_NUMBER {}
unsafe impl ::windows::core::Abi for WHEA_PCI_SLOT_NUMBER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union WHEA_PCI_SLOT_NUMBER_0 {
pub bits: WHEA_PCI_SLOT_NUMBER_0_0,
pub AsULONG: u32,
}
impl WHEA_PCI_SLOT_NUMBER_0 {}
impl ::core::default::Default for WHEA_PCI_SLOT_NUMBER_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_PCI_SLOT_NUMBER_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_PCI_SLOT_NUMBER_0 {}
unsafe impl ::windows::core::Abi for WHEA_PCI_SLOT_NUMBER_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct WHEA_PCI_SLOT_NUMBER_0_0 {
pub _bitfield: u32,
}
impl WHEA_PCI_SLOT_NUMBER_0_0 {}
impl ::core::default::Default for WHEA_PCI_SLOT_NUMBER_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WHEA_PCI_SLOT_NUMBER_0_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WHEA_PCI_SLOT_NUMBER_0_0 {}
unsafe impl ::windows::core::Abi for WHEA_PCI_SLOT_NUMBER_0_0 {
type Abi = Self;
}
pub const WHEA_PENDING_PAGE_LIST_SZ: u32 = 13u32;
pub const WHEA_RESTORE_CMCI_ATTEMPTS: u32 = 8u32;
pub const WHEA_RESTORE_CMCI_ENABLED: u32 = 7u32;
pub const WHEA_RESTORE_CMCI_ERR_LIMIT: u32 = 9u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_XPF_CMC_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
pub NumberOfBanks: u8,
pub Reserved: u32,
pub Notify: WHEA_NOTIFICATION_DESCRIPTOR,
pub Banks: [WHEA_XPF_MC_BANK_DESCRIPTOR; 32],
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_XPF_CMC_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_XPF_CMC_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_XPF_CMC_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_XPF_CMC_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_XPF_CMC_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_XPF_MCE_DESCRIPTOR {
pub Type: u16,
pub Enabled: u8,
pub NumberOfBanks: u8,
pub Flags: XPF_MCE_FLAGS,
pub MCG_Capability: u64,
pub MCG_GlobalControl: u64,
pub Banks: [WHEA_XPF_MC_BANK_DESCRIPTOR; 32],
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_XPF_MCE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_XPF_MCE_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_XPF_MCE_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_XPF_MCE_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_XPF_MCE_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_XPF_MC_BANK_DESCRIPTOR {
pub BankNumber: u8,
pub ClearOnInitialization: super::super::super::Foundation::BOOLEAN,
pub StatusDataFormat: u8,
pub Flags: XPF_MC_BANK_FLAGS,
pub ControlMsr: u32,
pub StatusMsr: u32,
pub AddressMsr: u32,
pub MiscMsr: u32,
pub ControlData: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_XPF_MC_BANK_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_XPF_MC_BANK_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_XPF_MC_BANK_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_XPF_MC_BANK_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_XPF_MC_BANK_DESCRIPTOR {
type Abi = Self;
}
pub const WHEA_XPF_MC_BANK_STATUSFORMAT_AMD64MCA: u32 = 2u32;
pub const WHEA_XPF_MC_BANK_STATUSFORMAT_IA32MCA: u32 = 0u32;
pub const WHEA_XPF_MC_BANK_STATUSFORMAT_Intel64MCA: u32 = 1u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
#[cfg(feature = "Win32_Foundation")]
pub struct WHEA_XPF_NMI_DESCRIPTOR {
pub Type: u16,
pub Enabled: super::super::super::Foundation::BOOLEAN,
}
#[cfg(feature = "Win32_Foundation")]
impl WHEA_XPF_NMI_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WHEA_XPF_NMI_DESCRIPTOR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WHEA_XPF_NMI_DESCRIPTOR {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WHEA_XPF_NMI_DESCRIPTOR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WHEA_XPF_NMI_DESCRIPTOR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct WINDBG_EXTENSION_APIS {
pub nSize: u32,
pub lpOutputRoutine: ::core::option::Option<PWINDBG_OUTPUT_ROUTINE>,
pub lpGetExpressionRoutine: ::core::option::Option<PWINDBG_GET_EXPRESSION>,
pub lpGetSymbolRoutine: ::core::option::Option<PWINDBG_GET_SYMBOL>,
pub lpDisasmRoutine: ::core::option::Option<PWINDBG_DISASM>,
pub lpCheckControlCRoutine: ::core::option::Option<PWINDBG_CHECK_CONTROL_C>,
pub lpReadProcessMemoryRoutine: ::core::option::Option<PWINDBG_READ_PROCESS_MEMORY_ROUTINE>,
pub lpWriteProcessMemoryRoutine: ::core::option::Option<PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE>,
pub lpGetThreadContextRoutine: ::core::option::Option<PWINDBG_GET_THREAD_CONTEXT_ROUTINE>,
pub lpSetThreadContextRoutine: ::core::option::Option<PWINDBG_SET_THREAD_CONTEXT_ROUTINE>,
pub lpIoctlRoutine: ::core::option::Option<PWINDBG_IOCTL_ROUTINE>,
pub lpStackTraceRoutine: ::core::option::Option<PWINDBG_STACKTRACE_ROUTINE>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl WINDBG_EXTENSION_APIS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for WINDBG_EXTENSION_APIS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for WINDBG_EXTENSION_APIS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WINDBG_EXTENSION_APIS").field("nSize", &self.nSize).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for WINDBG_EXTENSION_APIS {
fn eq(&self, other: &Self) -> bool {
self.nSize == other.nSize
&& self.lpOutputRoutine.map(|f| f as usize) == other.lpOutputRoutine.map(|f| f as usize)
&& self.lpGetExpressionRoutine.map(|f| f as usize) == other.lpGetExpressionRoutine.map(|f| f as usize)
&& self.lpGetSymbolRoutine.map(|f| f as usize) == other.lpGetSymbolRoutine.map(|f| f as usize)
&& self.lpDisasmRoutine.map(|f| f as usize) == other.lpDisasmRoutine.map(|f| f as usize)
&& self.lpCheckControlCRoutine.map(|f| f as usize) == other.lpCheckControlCRoutine.map(|f| f as usize)
&& self.lpReadProcessMemoryRoutine.map(|f| f as usize) == other.lpReadProcessMemoryRoutine.map(|f| f as usize)
&& self.lpWriteProcessMemoryRoutine.map(|f| f as usize) == other.lpWriteProcessMemoryRoutine.map(|f| f as usize)
&& self.lpGetThreadContextRoutine.map(|f| f as usize) == other.lpGetThreadContextRoutine.map(|f| f as usize)
&& self.lpSetThreadContextRoutine.map(|f| f as usize) == other.lpSetThreadContextRoutine.map(|f| f as usize)
&& self.lpIoctlRoutine.map(|f| f as usize) == other.lpIoctlRoutine.map(|f| f as usize)
&& self.lpStackTraceRoutine.map(|f| f as usize) == other.lpStackTraceRoutine.map(|f| f as usize)
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for WINDBG_EXTENSION_APIS {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for WINDBG_EXTENSION_APIS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct WINDBG_EXTENSION_APIS32 {
pub nSize: u32,
pub lpOutputRoutine: ::core::option::Option<PWINDBG_OUTPUT_ROUTINE>,
pub lpGetExpressionRoutine: ::core::option::Option<PWINDBG_GET_EXPRESSION32>,
pub lpGetSymbolRoutine: ::core::option::Option<PWINDBG_GET_SYMBOL32>,
pub lpDisasmRoutine: ::core::option::Option<PWINDBG_DISASM32>,
pub lpCheckControlCRoutine: ::core::option::Option<PWINDBG_CHECK_CONTROL_C>,
pub lpReadProcessMemoryRoutine: ::core::option::Option<PWINDBG_READ_PROCESS_MEMORY_ROUTINE32>,
pub lpWriteProcessMemoryRoutine: ::core::option::Option<PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32>,
pub lpGetThreadContextRoutine: ::core::option::Option<PWINDBG_GET_THREAD_CONTEXT_ROUTINE>,
pub lpSetThreadContextRoutine: ::core::option::Option<PWINDBG_SET_THREAD_CONTEXT_ROUTINE>,
pub lpIoctlRoutine: ::core::option::Option<PWINDBG_IOCTL_ROUTINE>,
pub lpStackTraceRoutine: ::core::option::Option<PWINDBG_STACKTRACE_ROUTINE32>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl WINDBG_EXTENSION_APIS32 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for WINDBG_EXTENSION_APIS32 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for WINDBG_EXTENSION_APIS32 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WINDBG_EXTENSION_APIS32").field("nSize", &self.nSize).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for WINDBG_EXTENSION_APIS32 {
fn eq(&self, other: &Self) -> bool {
self.nSize == other.nSize
&& self.lpOutputRoutine.map(|f| f as usize) == other.lpOutputRoutine.map(|f| f as usize)
&& self.lpGetExpressionRoutine.map(|f| f as usize) == other.lpGetExpressionRoutine.map(|f| f as usize)
&& self.lpGetSymbolRoutine.map(|f| f as usize) == other.lpGetSymbolRoutine.map(|f| f as usize)
&& self.lpDisasmRoutine.map(|f| f as usize) == other.lpDisasmRoutine.map(|f| f as usize)
&& self.lpCheckControlCRoutine.map(|f| f as usize) == other.lpCheckControlCRoutine.map(|f| f as usize)
&& self.lpReadProcessMemoryRoutine.map(|f| f as usize) == other.lpReadProcessMemoryRoutine.map(|f| f as usize)
&& self.lpWriteProcessMemoryRoutine.map(|f| f as usize) == other.lpWriteProcessMemoryRoutine.map(|f| f as usize)
&& self.lpGetThreadContextRoutine.map(|f| f as usize) == other.lpGetThreadContextRoutine.map(|f| f as usize)
&& self.lpSetThreadContextRoutine.map(|f| f as usize) == other.lpSetThreadContextRoutine.map(|f| f as usize)
&& self.lpIoctlRoutine.map(|f| f as usize) == other.lpIoctlRoutine.map(|f| f as usize)
&& self.lpStackTraceRoutine.map(|f| f as usize) == other.lpStackTraceRoutine.map(|f| f as usize)
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for WINDBG_EXTENSION_APIS32 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for WINDBG_EXTENSION_APIS32 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
pub struct WINDBG_EXTENSION_APIS64 {
pub nSize: u32,
pub lpOutputRoutine: ::core::option::Option<PWINDBG_OUTPUT_ROUTINE>,
pub lpGetExpressionRoutine: ::core::option::Option<PWINDBG_GET_EXPRESSION64>,
pub lpGetSymbolRoutine: ::core::option::Option<PWINDBG_GET_SYMBOL64>,
pub lpDisasmRoutine: ::core::option::Option<PWINDBG_DISASM64>,
pub lpCheckControlCRoutine: ::core::option::Option<PWINDBG_CHECK_CONTROL_C>,
pub lpReadProcessMemoryRoutine: ::core::option::Option<PWINDBG_READ_PROCESS_MEMORY_ROUTINE64>,
pub lpWriteProcessMemoryRoutine: ::core::option::Option<PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE64>,
pub lpGetThreadContextRoutine: ::core::option::Option<PWINDBG_GET_THREAD_CONTEXT_ROUTINE>,
pub lpSetThreadContextRoutine: ::core::option::Option<PWINDBG_SET_THREAD_CONTEXT_ROUTINE>,
pub lpIoctlRoutine: ::core::option::Option<PWINDBG_IOCTL_ROUTINE>,
pub lpStackTraceRoutine: ::core::option::Option<PWINDBG_STACKTRACE_ROUTINE64>,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl WINDBG_EXTENSION_APIS64 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::default::Default for WINDBG_EXTENSION_APIS64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::fmt::Debug for WINDBG_EXTENSION_APIS64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WINDBG_EXTENSION_APIS64").field("nSize", &self.nSize).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::PartialEq for WINDBG_EXTENSION_APIS64 {
fn eq(&self, other: &Self) -> bool {
self.nSize == other.nSize
&& self.lpOutputRoutine.map(|f| f as usize) == other.lpOutputRoutine.map(|f| f as usize)
&& self.lpGetExpressionRoutine.map(|f| f as usize) == other.lpGetExpressionRoutine.map(|f| f as usize)
&& self.lpGetSymbolRoutine.map(|f| f as usize) == other.lpGetSymbolRoutine.map(|f| f as usize)
&& self.lpDisasmRoutine.map(|f| f as usize) == other.lpDisasmRoutine.map(|f| f as usize)
&& self.lpCheckControlCRoutine.map(|f| f as usize) == other.lpCheckControlCRoutine.map(|f| f as usize)
&& self.lpReadProcessMemoryRoutine.map(|f| f as usize) == other.lpReadProcessMemoryRoutine.map(|f| f as usize)
&& self.lpWriteProcessMemoryRoutine.map(|f| f as usize) == other.lpWriteProcessMemoryRoutine.map(|f| f as usize)
&& self.lpGetThreadContextRoutine.map(|f| f as usize) == other.lpGetThreadContextRoutine.map(|f| f as usize)
&& self.lpSetThreadContextRoutine.map(|f| f as usize) == other.lpSetThreadContextRoutine.map(|f| f as usize)
&& self.lpIoctlRoutine.map(|f| f as usize) == other.lpIoctlRoutine.map(|f| f as usize)
&& self.lpStackTraceRoutine.map(|f| f as usize) == other.lpStackTraceRoutine.map(|f| f as usize)
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
impl ::core::cmp::Eq for WINDBG_EXTENSION_APIS64 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Kernel"))]
unsafe impl ::windows::core::Abi for WINDBG_EXTENSION_APIS64 {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WINDBG_OLDKD_EXTENSION_APIS {
pub nSize: u32,
pub lpOutputRoutine: ::core::option::Option<PWINDBG_OUTPUT_ROUTINE>,
pub lpGetExpressionRoutine: ::core::option::Option<PWINDBG_GET_EXPRESSION32>,
pub lpGetSymbolRoutine: ::core::option::Option<PWINDBG_GET_SYMBOL32>,
pub lpDisasmRoutine: ::core::option::Option<PWINDBG_DISASM32>,
pub lpCheckControlCRoutine: ::core::option::Option<PWINDBG_CHECK_CONTROL_C>,
pub lpReadVirtualMemRoutine: ::core::option::Option<PWINDBG_READ_PROCESS_MEMORY_ROUTINE32>,
pub lpWriteVirtualMemRoutine: ::core::option::Option<PWINDBG_WRITE_PROCESS_MEMORY_ROUTINE32>,
pub lpReadPhysicalMemRoutine: ::core::option::Option<PWINDBG_OLDKD_READ_PHYSICAL_MEMORY>,
pub lpWritePhysicalMemRoutine: ::core::option::Option<PWINDBG_OLDKD_WRITE_PHYSICAL_MEMORY>,
}
#[cfg(feature = "Win32_Foundation")]
impl WINDBG_OLDKD_EXTENSION_APIS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WINDBG_OLDKD_EXTENSION_APIS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for WINDBG_OLDKD_EXTENSION_APIS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WINDBG_OLDKD_EXTENSION_APIS").field("nSize", &self.nSize).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WINDBG_OLDKD_EXTENSION_APIS {
fn eq(&self, other: &Self) -> bool {
self.nSize == other.nSize
&& self.lpOutputRoutine.map(|f| f as usize) == other.lpOutputRoutine.map(|f| f as usize)
&& self.lpGetExpressionRoutine.map(|f| f as usize) == other.lpGetExpressionRoutine.map(|f| f as usize)
&& self.lpGetSymbolRoutine.map(|f| f as usize) == other.lpGetSymbolRoutine.map(|f| f as usize)
&& self.lpDisasmRoutine.map(|f| f as usize) == other.lpDisasmRoutine.map(|f| f as usize)
&& self.lpCheckControlCRoutine.map(|f| f as usize) == other.lpCheckControlCRoutine.map(|f| f as usize)
&& self.lpReadVirtualMemRoutine.map(|f| f as usize) == other.lpReadVirtualMemRoutine.map(|f| f as usize)
&& self.lpWriteVirtualMemRoutine.map(|f| f as usize) == other.lpWriteVirtualMemRoutine.map(|f| f as usize)
&& self.lpReadPhysicalMemRoutine.map(|f| f as usize) == other.lpReadPhysicalMemRoutine.map(|f| f as usize)
&& self.lpWritePhysicalMemRoutine.map(|f| f as usize) == other.lpWritePhysicalMemRoutine.map(|f| f as usize)
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WINDBG_OLDKD_EXTENSION_APIS {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WINDBG_OLDKD_EXTENSION_APIS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct WINDBG_OLD_EXTENSION_APIS {
pub nSize: u32,
pub lpOutputRoutine: ::core::option::Option<PWINDBG_OUTPUT_ROUTINE>,
pub lpGetExpressionRoutine: ::core::option::Option<PWINDBG_GET_EXPRESSION>,
pub lpGetSymbolRoutine: ::core::option::Option<PWINDBG_GET_SYMBOL>,
pub lpDisasmRoutine: ::core::option::Option<PWINDBG_DISASM>,
pub lpCheckControlCRoutine: ::core::option::Option<PWINDBG_CHECK_CONTROL_C>,
}
#[cfg(feature = "Win32_Foundation")]
impl WINDBG_OLD_EXTENSION_APIS {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for WINDBG_OLD_EXTENSION_APIS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for WINDBG_OLD_EXTENSION_APIS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WINDBG_OLD_EXTENSION_APIS").field("nSize", &self.nSize).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for WINDBG_OLD_EXTENSION_APIS {
fn eq(&self, other: &Self) -> bool {
self.nSize == other.nSize
&& self.lpOutputRoutine.map(|f| f as usize) == other.lpOutputRoutine.map(|f| f as usize)
&& self.lpGetExpressionRoutine.map(|f| f as usize) == other.lpGetExpressionRoutine.map(|f| f as usize)
&& self.lpGetSymbolRoutine.map(|f| f as usize) == other.lpGetSymbolRoutine.map(|f| f as usize)
&& self.lpDisasmRoutine.map(|f| f as usize) == other.lpDisasmRoutine.map(|f| f as usize)
&& self.lpCheckControlCRoutine.map(|f| f as usize) == other.lpCheckControlCRoutine.map(|f| f as usize)
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for WINDBG_OLD_EXTENSION_APIS {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for WINDBG_OLD_EXTENSION_APIS {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_CONTEXT {
pub ContextFlags: u32,
pub Dr0: u32,
pub Dr1: u32,
pub Dr2: u32,
pub Dr3: u32,
pub Dr6: u32,
pub Dr7: u32,
pub FloatSave: WOW64_FLOATING_SAVE_AREA,
pub SegGs: u32,
pub SegFs: u32,
pub SegEs: u32,
pub SegDs: u32,
pub Edi: u32,
pub Esi: u32,
pub Ebx: u32,
pub Edx: u32,
pub Ecx: u32,
pub Eax: u32,
pub Ebp: u32,
pub Eip: u32,
pub SegCs: u32,
pub EFlags: u32,
pub Esp: u32,
pub SegSs: u32,
pub ExtendedRegisters: [u8; 512],
}
impl WOW64_CONTEXT {}
impl ::core::default::Default for WOW64_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WOW64_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WOW64_CONTEXT")
.field("ContextFlags", &self.ContextFlags)
.field("Dr0", &self.Dr0)
.field("Dr1", &self.Dr1)
.field("Dr2", &self.Dr2)
.field("Dr3", &self.Dr3)
.field("Dr6", &self.Dr6)
.field("Dr7", &self.Dr7)
.field("FloatSave", &self.FloatSave)
.field("SegGs", &self.SegGs)
.field("SegFs", &self.SegFs)
.field("SegEs", &self.SegEs)
.field("SegDs", &self.SegDs)
.field("Edi", &self.Edi)
.field("Esi", &self.Esi)
.field("Ebx", &self.Ebx)
.field("Edx", &self.Edx)
.field("Ecx", &self.Ecx)
.field("Eax", &self.Eax)
.field("Ebp", &self.Ebp)
.field("Eip", &self.Eip)
.field("SegCs", &self.SegCs)
.field("EFlags", &self.EFlags)
.field("Esp", &self.Esp)
.field("SegSs", &self.SegSs)
.field("ExtendedRegisters", &self.ExtendedRegisters)
.finish()
}
}
impl ::core::cmp::PartialEq for WOW64_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.ContextFlags == other.ContextFlags
&& self.Dr0 == other.Dr0
&& self.Dr1 == other.Dr1
&& self.Dr2 == other.Dr2
&& self.Dr3 == other.Dr3
&& self.Dr6 == other.Dr6
&& self.Dr7 == other.Dr7
&& self.FloatSave == other.FloatSave
&& self.SegGs == other.SegGs
&& self.SegFs == other.SegFs
&& self.SegEs == other.SegEs
&& self.SegDs == other.SegDs
&& self.Edi == other.Edi
&& self.Esi == other.Esi
&& self.Ebx == other.Ebx
&& self.Edx == other.Edx
&& self.Ecx == other.Ecx
&& self.Eax == other.Eax
&& self.Ebp == other.Ebp
&& self.Eip == other.Eip
&& self.SegCs == other.SegCs
&& self.EFlags == other.EFlags
&& self.Esp == other.Esp
&& self.SegSs == other.SegSs
&& self.ExtendedRegisters == other.ExtendedRegisters
}
}
impl ::core::cmp::Eq for WOW64_CONTEXT {}
unsafe impl ::windows::core::Abi for WOW64_CONTEXT {
type Abi = Self;
}
pub const WOW64_CONTEXT_EXCEPTION_ACTIVE: u32 = 134217728u32;
pub const WOW64_CONTEXT_EXCEPTION_REPORTING: u32 = 2147483648u32;
pub const WOW64_CONTEXT_EXCEPTION_REQUEST: u32 = 1073741824u32;
pub const WOW64_CONTEXT_SERVICE_ACTIVE: u32 = 268435456u32;
pub const WOW64_CONTEXT_i386: u32 = 65536u32;
pub const WOW64_CONTEXT_i486: u32 = 65536u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_DESCRIPTOR_TABLE_ENTRY {
pub Selector: u32,
pub Descriptor: WOW64_LDT_ENTRY,
}
impl WOW64_DESCRIPTOR_TABLE_ENTRY {}
impl ::core::default::Default for WOW64_DESCRIPTOR_TABLE_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WOW64_DESCRIPTOR_TABLE_ENTRY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WOW64_DESCRIPTOR_TABLE_ENTRY {}
unsafe impl ::windows::core::Abi for WOW64_DESCRIPTOR_TABLE_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_FLOATING_SAVE_AREA {
pub ControlWord: u32,
pub StatusWord: u32,
pub TagWord: u32,
pub ErrorOffset: u32,
pub ErrorSelector: u32,
pub DataOffset: u32,
pub DataSelector: u32,
pub RegisterArea: [u8; 80],
pub Cr0NpxState: u32,
}
impl WOW64_FLOATING_SAVE_AREA {}
impl ::core::default::Default for WOW64_FLOATING_SAVE_AREA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WOW64_FLOATING_SAVE_AREA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("WOW64_FLOATING_SAVE_AREA")
.field("ControlWord", &self.ControlWord)
.field("StatusWord", &self.StatusWord)
.field("TagWord", &self.TagWord)
.field("ErrorOffset", &self.ErrorOffset)
.field("ErrorSelector", &self.ErrorSelector)
.field("DataOffset", &self.DataOffset)
.field("DataSelector", &self.DataSelector)
.field("RegisterArea", &self.RegisterArea)
.field("Cr0NpxState", &self.Cr0NpxState)
.finish()
}
}
impl ::core::cmp::PartialEq for WOW64_FLOATING_SAVE_AREA {
fn eq(&self, other: &Self) -> bool {
self.ControlWord == other.ControlWord && self.StatusWord == other.StatusWord && self.TagWord == other.TagWord && self.ErrorOffset == other.ErrorOffset && self.ErrorSelector == other.ErrorSelector && self.DataOffset == other.DataOffset && self.DataSelector == other.DataSelector && self.RegisterArea == other.RegisterArea && self.Cr0NpxState == other.Cr0NpxState
}
}
impl ::core::cmp::Eq for WOW64_FLOATING_SAVE_AREA {}
unsafe impl ::windows::core::Abi for WOW64_FLOATING_SAVE_AREA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_LDT_ENTRY {
pub LimitLow: u16,
pub BaseLow: u16,
pub HighWord: WOW64_LDT_ENTRY_0,
}
impl WOW64_LDT_ENTRY {}
impl ::core::default::Default for WOW64_LDT_ENTRY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WOW64_LDT_ENTRY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WOW64_LDT_ENTRY {}
unsafe impl ::windows::core::Abi for WOW64_LDT_ENTRY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union WOW64_LDT_ENTRY_0 {
pub Bytes: WOW64_LDT_ENTRY_0_1,
pub Bits: WOW64_LDT_ENTRY_0_0,
}
impl WOW64_LDT_ENTRY_0 {}
impl ::core::default::Default for WOW64_LDT_ENTRY_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for WOW64_LDT_ENTRY_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for WOW64_LDT_ENTRY_0 {}
unsafe impl ::windows::core::Abi for WOW64_LDT_ENTRY_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_LDT_ENTRY_0_0 {
pub _bitfield: u32,
}
impl WOW64_LDT_ENTRY_0_0 {}
impl ::core::default::Default for WOW64_LDT_ENTRY_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WOW64_LDT_ENTRY_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Bits_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for WOW64_LDT_ENTRY_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for WOW64_LDT_ENTRY_0_0 {}
unsafe impl ::windows::core::Abi for WOW64_LDT_ENTRY_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct WOW64_LDT_ENTRY_0_1 {
pub BaseMid: u8,
pub Flags1: u8,
pub Flags2: u8,
pub BaseHi: u8,
}
impl WOW64_LDT_ENTRY_0_1 {}
impl ::core::default::Default for WOW64_LDT_ENTRY_0_1 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for WOW64_LDT_ENTRY_0_1 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Bytes_e__Struct").field("BaseMid", &self.BaseMid).field("Flags1", &self.Flags1).field("Flags2", &self.Flags2).field("BaseHi", &self.BaseHi).finish()
}
}
impl ::core::cmp::PartialEq for WOW64_LDT_ENTRY_0_1 {
fn eq(&self, other: &Self) -> bool {
self.BaseMid == other.BaseMid && self.Flags1 == other.Flags1 && self.Flags2 == other.Flags2 && self.BaseHi == other.BaseHi
}
}
impl ::core::cmp::Eq for WOW64_LDT_ENTRY_0_1 {}
unsafe impl ::windows::core::Abi for WOW64_LDT_ENTRY_0_1 {
type Abi = Self;
}
pub const WOW64_MAXIMUM_SUPPORTED_EXTENSION: u32 = 512u32;
pub const WOW64_SIZE_OF_80387_REGISTERS: u32 = 80u32;
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
#[inline]
pub unsafe fn WaitForDebugEvent(lpdebugevent: *mut DEBUG_EVENT, dwmilliseconds: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn WaitForDebugEvent(lpdebugevent: *mut ::core::mem::ManuallyDrop<DEBUG_EVENT>, dwmilliseconds: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(WaitForDebugEvent(::core::mem::transmute(lpdebugevent), ::core::mem::transmute(dwmilliseconds)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Threading"))]
#[inline]
pub unsafe fn WaitForDebugEventEx(lpdebugevent: *mut DEBUG_EVENT, dwmilliseconds: u32) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn WaitForDebugEventEx(lpdebugevent: *mut ::core::mem::ManuallyDrop<DEBUG_EVENT>, dwmilliseconds: u32) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(WaitForDebugEventEx(::core::mem::transmute(lpdebugevent), ::core::mem::transmute(dwmilliseconds)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Wow64GetThreadContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, lpcontext: *mut WOW64_CONTEXT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Wow64GetThreadContext(hthread: super::super::super::Foundation::HANDLE, lpcontext: *mut WOW64_CONTEXT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(Wow64GetThreadContext(hthread.into_param().abi(), ::core::mem::transmute(lpcontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Wow64GetThreadSelectorEntry<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, dwselector: u32, lpselectorentry: *mut WOW64_LDT_ENTRY) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Wow64GetThreadSelectorEntry(hthread: super::super::super::Foundation::HANDLE, dwselector: u32, lpselectorentry: *mut WOW64_LDT_ENTRY) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(Wow64GetThreadSelectorEntry(hthread.into_param().abi(), ::core::mem::transmute(dwselector), ::core::mem::transmute(lpselectorentry)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn Wow64SetThreadContext<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hthread: Param0, lpcontext: *const WOW64_CONTEXT) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn Wow64SetThreadContext(hthread: super::super::super::Foundation::HANDLE, lpcontext: *const WOW64_CONTEXT) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(Wow64SetThreadContext(hthread.into_param().abi(), ::core::mem::transmute(lpcontext)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[cfg(feature = "Win32_Foundation")]
#[inline]
pub unsafe fn WriteProcessMemory<'a, Param0: ::windows::core::IntoParam<'a, super::super::super::Foundation::HANDLE>>(hprocess: Param0, lpbaseaddress: *const ::core::ffi::c_void, lpbuffer: *const ::core::ffi::c_void, nsize: usize, lpnumberofbyteswritten: *mut usize) -> super::super::super::Foundation::BOOL {
#[cfg(windows)]
{
#[link(name = "windows")]
extern "system" {
fn WriteProcessMemory(hprocess: super::super::super::Foundation::HANDLE, lpbaseaddress: *const ::core::ffi::c_void, lpbuffer: *const ::core::ffi::c_void, nsize: usize, lpnumberofbyteswritten: *mut usize) -> super::super::super::Foundation::BOOL;
}
::core::mem::transmute(WriteProcessMemory(hprocess.into_param().abi(), ::core::mem::transmute(lpbaseaddress), ::core::mem::transmute(lpbuffer), ::core::mem::transmute(nsize), ::core::mem::transmute(lpnumberofbyteswritten)))
}
#[cfg(not(windows))]
unimplemented!("Unsupported target OS");
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub union XPF_MCE_FLAGS {
pub Anonymous: XPF_MCE_FLAGS_0,
pub AsULONG: u32,
}
impl XPF_MCE_FLAGS {}
impl ::core::default::Default for XPF_MCE_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XPF_MCE_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XPF_MCE_FLAGS {}
unsafe impl ::windows::core::Abi for XPF_MCE_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(1))]
pub struct XPF_MCE_FLAGS_0 {
pub _bitfield: u32,
}
impl XPF_MCE_FLAGS_0 {}
impl ::core::default::Default for XPF_MCE_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XPF_MCE_FLAGS_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XPF_MCE_FLAGS_0 {}
unsafe impl ::windows::core::Abi for XPF_MCE_FLAGS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union XPF_MC_BANK_FLAGS {
pub Anonymous: XPF_MC_BANK_FLAGS_0,
pub AsUCHAR: u8,
}
impl XPF_MC_BANK_FLAGS {}
impl ::core::default::Default for XPF_MC_BANK_FLAGS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XPF_MC_BANK_FLAGS {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XPF_MC_BANK_FLAGS {}
unsafe impl ::windows::core::Abi for XPF_MC_BANK_FLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XPF_MC_BANK_FLAGS_0 {
pub _bitfield: u8,
}
impl XPF_MC_BANK_FLAGS_0 {}
impl ::core::default::Default for XPF_MC_BANK_FLAGS_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for XPF_MC_BANK_FLAGS_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for XPF_MC_BANK_FLAGS_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for XPF_MC_BANK_FLAGS_0 {}
unsafe impl ::windows::core::Abi for XPF_MC_BANK_FLAGS_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XSAVE_AREA {
pub LegacyState: XSAVE_FORMAT,
pub Header: XSAVE_AREA_HEADER,
}
impl XSAVE_AREA {}
impl ::core::default::Default for XSAVE_AREA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for XSAVE_AREA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSAVE_AREA").field("LegacyState", &self.LegacyState).field("Header", &self.Header).finish()
}
}
impl ::core::cmp::PartialEq for XSAVE_AREA {
fn eq(&self, other: &Self) -> bool {
self.LegacyState == other.LegacyState && self.Header == other.Header
}
}
impl ::core::cmp::Eq for XSAVE_AREA {}
unsafe impl ::windows::core::Abi for XSAVE_AREA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XSAVE_AREA_HEADER {
pub Mask: u64,
pub CompactionMask: u64,
pub Reserved2: [u64; 6],
}
impl XSAVE_AREA_HEADER {}
impl ::core::default::Default for XSAVE_AREA_HEADER {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for XSAVE_AREA_HEADER {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSAVE_AREA_HEADER").field("Mask", &self.Mask).field("CompactionMask", &self.CompactionMask).field("Reserved2", &self.Reserved2).finish()
}
}
impl ::core::cmp::PartialEq for XSAVE_AREA_HEADER {
fn eq(&self, other: &Self) -> bool {
self.Mask == other.Mask && self.CompactionMask == other.CompactionMask && self.Reserved2 == other.Reserved2
}
}
impl ::core::cmp::Eq for XSAVE_AREA_HEADER {}
unsafe impl ::windows::core::Abi for XSAVE_AREA_HEADER {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
pub struct XSAVE_FORMAT {
pub ControlWord: u16,
pub StatusWord: u16,
pub TagWord: u8,
pub Reserved1: u8,
pub ErrorOpcode: u16,
pub ErrorOffset: u32,
pub ErrorSelector: u16,
pub Reserved2: u16,
pub DataOffset: u32,
pub DataSelector: u16,
pub Reserved3: u16,
pub MxCsr: u32,
pub MxCsr_Mask: u32,
pub FloatRegisters: [M128A; 8],
pub XmmRegisters: [M128A; 16],
pub Reserved4: [u8; 96],
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl XSAVE_FORMAT {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::default::Default for XSAVE_FORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::fmt::Debug for XSAVE_FORMAT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSAVE_FORMAT")
.field("ControlWord", &self.ControlWord)
.field("StatusWord", &self.StatusWord)
.field("TagWord", &self.TagWord)
.field("Reserved1", &self.Reserved1)
.field("ErrorOpcode", &self.ErrorOpcode)
.field("ErrorOffset", &self.ErrorOffset)
.field("ErrorSelector", &self.ErrorSelector)
.field("Reserved2", &self.Reserved2)
.field("DataOffset", &self.DataOffset)
.field("DataSelector", &self.DataSelector)
.field("Reserved3", &self.Reserved3)
.field("MxCsr", &self.MxCsr)
.field("MxCsr_Mask", &self.MxCsr_Mask)
.field("FloatRegisters", &self.FloatRegisters)
.field("XmmRegisters", &self.XmmRegisters)
.field("Reserved4", &self.Reserved4)
.finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for XSAVE_FORMAT {
fn eq(&self, other: &Self) -> bool {
self.ControlWord == other.ControlWord
&& self.StatusWord == other.StatusWord
&& self.TagWord == other.TagWord
&& self.Reserved1 == other.Reserved1
&& self.ErrorOpcode == other.ErrorOpcode
&& self.ErrorOffset == other.ErrorOffset
&& self.ErrorSelector == other.ErrorSelector
&& self.Reserved2 == other.Reserved2
&& self.DataOffset == other.DataOffset
&& self.DataSelector == other.DataSelector
&& self.Reserved3 == other.Reserved3
&& self.MxCsr == other.MxCsr
&& self.MxCsr_Mask == other.MxCsr_Mask
&& self.FloatRegisters == other.FloatRegisters
&& self.XmmRegisters == other.XmmRegisters
&& self.Reserved4 == other.Reserved4
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::Eq for XSAVE_FORMAT {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for XSAVE_FORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct XSAVE_FORMAT {
pub ControlWord: u16,
pub StatusWord: u16,
pub TagWord: u8,
pub Reserved1: u8,
pub ErrorOpcode: u16,
pub ErrorOffset: u32,
pub ErrorSelector: u16,
pub Reserved2: u16,
pub DataOffset: u32,
pub DataSelector: u16,
pub Reserved3: u16,
pub MxCsr: u32,
pub MxCsr_Mask: u32,
pub FloatRegisters: [M128A; 8],
pub XmmRegisters: [M128A; 8],
pub Reserved4: [u8; 224],
}
#[cfg(any(target_arch = "x86",))]
impl XSAVE_FORMAT {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for XSAVE_FORMAT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for XSAVE_FORMAT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSAVE_FORMAT")
.field("ControlWord", &self.ControlWord)
.field("StatusWord", &self.StatusWord)
.field("TagWord", &self.TagWord)
.field("Reserved1", &self.Reserved1)
.field("ErrorOpcode", &self.ErrorOpcode)
.field("ErrorOffset", &self.ErrorOffset)
.field("ErrorSelector", &self.ErrorSelector)
.field("Reserved2", &self.Reserved2)
.field("DataOffset", &self.DataOffset)
.field("DataSelector", &self.DataSelector)
.field("Reserved3", &self.Reserved3)
.field("MxCsr", &self.MxCsr)
.field("MxCsr_Mask", &self.MxCsr_Mask)
.field("FloatRegisters", &self.FloatRegisters)
.field("XmmRegisters", &self.XmmRegisters)
.field("Reserved4", &self.Reserved4)
.finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for XSAVE_FORMAT {
fn eq(&self, other: &Self) -> bool {
self.ControlWord == other.ControlWord
&& self.StatusWord == other.StatusWord
&& self.TagWord == other.TagWord
&& self.Reserved1 == other.Reserved1
&& self.ErrorOpcode == other.ErrorOpcode
&& self.ErrorOffset == other.ErrorOffset
&& self.ErrorSelector == other.ErrorSelector
&& self.Reserved2 == other.Reserved2
&& self.DataOffset == other.DataOffset
&& self.DataSelector == other.DataSelector
&& self.Reserved3 == other.Reserved3
&& self.MxCsr == other.MxCsr
&& self.MxCsr_Mask == other.MxCsr_Mask
&& self.FloatRegisters == other.FloatRegisters
&& self.XmmRegisters == other.XmmRegisters
&& self.Reserved4 == other.Reserved4
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for XSAVE_FORMAT {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for XSAVE_FORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XSTATE_CONFIGURATION {
pub EnabledFeatures: u64,
pub EnabledVolatileFeatures: u64,
pub Size: u32,
pub Anonymous: XSTATE_CONFIGURATION_0,
pub Features: [XSTATE_FEATURE; 64],
pub EnabledSupervisorFeatures: u64,
pub AlignedFeatures: u64,
pub AllFeatureSize: u32,
pub AllFeatures: [u32; 64],
pub EnabledUserVisibleSupervisorFeatures: u64,
pub ExtendedFeatureDisableFeatures: u64,
pub AllNonLargeFeatureSize: u32,
pub Spare: u32,
}
impl XSTATE_CONFIGURATION {}
impl ::core::default::Default for XSTATE_CONFIGURATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XSTATE_CONFIGURATION {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XSTATE_CONFIGURATION {}
unsafe impl ::windows::core::Abi for XSTATE_CONFIGURATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub union XSTATE_CONFIGURATION_0 {
pub ControlFlags: u32,
pub Anonymous: XSTATE_CONFIGURATION_0_0,
}
impl XSTATE_CONFIGURATION_0 {}
impl ::core::default::Default for XSTATE_CONFIGURATION_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XSTATE_CONFIGURATION_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XSTATE_CONFIGURATION_0 {}
unsafe impl ::windows::core::Abi for XSTATE_CONFIGURATION_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XSTATE_CONFIGURATION_0_0 {
pub _bitfield: u32,
}
impl XSTATE_CONFIGURATION_0_0 {}
impl ::core::default::Default for XSTATE_CONFIGURATION_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for XSTATE_CONFIGURATION_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("_bitfield", &self._bitfield).finish()
}
}
impl ::core::cmp::PartialEq for XSTATE_CONFIGURATION_0_0 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield
}
}
impl ::core::cmp::Eq for XSTATE_CONFIGURATION_0_0 {}
unsafe impl ::windows::core::Abi for XSTATE_CONFIGURATION_0_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C, packed(4))]
pub struct XSTATE_CONFIG_FEATURE_MSC_INFO {
pub SizeOfInfo: u32,
pub ContextSize: u32,
pub EnabledFeatures: u64,
pub Features: [XSTATE_FEATURE; 64],
}
impl XSTATE_CONFIG_FEATURE_MSC_INFO {}
impl ::core::default::Default for XSTATE_CONFIG_FEATURE_MSC_INFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::cmp::PartialEq for XSTATE_CONFIG_FEATURE_MSC_INFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
impl ::core::cmp::Eq for XSTATE_CONFIG_FEATURE_MSC_INFO {}
unsafe impl ::windows::core::Abi for XSTATE_CONFIG_FEATURE_MSC_INFO {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
pub struct XSTATE_CONTEXT {
pub Mask: u64,
pub Length: u32,
pub Reserved1: u32,
pub Area: *mut XSAVE_AREA,
pub Buffer: *mut ::core::ffi::c_void,
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl XSTATE_CONTEXT {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::default::Default for XSTATE_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::fmt::Debug for XSTATE_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSTATE_CONTEXT").field("Mask", &self.Mask).field("Length", &self.Length).field("Reserved1", &self.Reserved1).field("Area", &self.Area).field("Buffer", &self.Buffer).finish()
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::PartialEq for XSTATE_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.Mask == other.Mask && self.Length == other.Length && self.Reserved1 == other.Reserved1 && self.Area == other.Area && self.Buffer == other.Buffer
}
}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
impl ::core::cmp::Eq for XSTATE_CONTEXT {}
#[cfg(any(target_arch = "x86_64", target_arch = "aarch64",))]
unsafe impl ::windows::core::Abi for XSTATE_CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(any(target_arch = "x86",))]
pub struct XSTATE_CONTEXT {
pub Mask: u64,
pub Length: u32,
pub Reserved1: u32,
pub Area: *mut XSAVE_AREA,
pub Reserved2: u32,
pub Buffer: *mut ::core::ffi::c_void,
pub Reserved3: u32,
}
#[cfg(any(target_arch = "x86",))]
impl XSTATE_CONTEXT {}
#[cfg(any(target_arch = "x86",))]
impl ::core::default::Default for XSTATE_CONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::fmt::Debug for XSTATE_CONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSTATE_CONTEXT").field("Mask", &self.Mask).field("Length", &self.Length).field("Reserved1", &self.Reserved1).field("Area", &self.Area).field("Reserved2", &self.Reserved2).field("Buffer", &self.Buffer).field("Reserved3", &self.Reserved3).finish()
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::PartialEq for XSTATE_CONTEXT {
fn eq(&self, other: &Self) -> bool {
self.Mask == other.Mask && self.Length == other.Length && self.Reserved1 == other.Reserved1 && self.Area == other.Area && self.Reserved2 == other.Reserved2 && self.Buffer == other.Buffer && self.Reserved3 == other.Reserved3
}
}
#[cfg(any(target_arch = "x86",))]
impl ::core::cmp::Eq for XSTATE_CONTEXT {}
#[cfg(any(target_arch = "x86",))]
unsafe impl ::windows::core::Abi for XSTATE_CONTEXT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct XSTATE_FEATURE {
pub Offset: u32,
pub Size: u32,
}
impl XSTATE_FEATURE {}
impl ::core::default::Default for XSTATE_FEATURE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for XSTATE_FEATURE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("XSTATE_FEATURE").field("Offset", &self.Offset).field("Size", &self.Size).finish()
}
}
impl ::core::cmp::PartialEq for XSTATE_FEATURE {
fn eq(&self, other: &Self) -> bool {
self.Offset == other.Offset && self.Size == other.Size
}
}
impl ::core::cmp::Eq for XSTATE_FEATURE {}
unsafe impl ::windows::core::Abi for XSTATE_FEATURE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct _DUMP_TYPES(pub i32);
pub const DUMP_TYPE_INVALID: _DUMP_TYPES = _DUMP_TYPES(-1i32);
pub const DUMP_TYPE_UNKNOWN: _DUMP_TYPES = _DUMP_TYPES(0i32);
pub const DUMP_TYPE_FULL: _DUMP_TYPES = _DUMP_TYPES(1i32);
pub const DUMP_TYPE_SUMMARY: _DUMP_TYPES = _DUMP_TYPES(2i32);
pub const DUMP_TYPE_HEADER: _DUMP_TYPES = _DUMP_TYPES(3i32);
pub const DUMP_TYPE_TRIAGE: _DUMP_TYPES = _DUMP_TYPES(4i32);
pub const DUMP_TYPE_BITMAP_FULL: _DUMP_TYPES = _DUMP_TYPES(5i32);
pub const DUMP_TYPE_BITMAP_KERNEL: _DUMP_TYPES = _DUMP_TYPES(6i32);
pub const DUMP_TYPE_AUTOMATIC: _DUMP_TYPES = _DUMP_TYPES(7i32);
impl ::core::convert::From<i32> for _DUMP_TYPES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for _DUMP_TYPES {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct _GETSETBUSDATA {
pub BusDataType: u32,
pub BusNumber: u32,
pub SlotNumber: u32,
pub Buffer: *mut ::core::ffi::c_void,
pub Offset: u32,
pub Length: u32,
}
impl _GETSETBUSDATA {}
impl ::core::default::Default for _GETSETBUSDATA {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for _GETSETBUSDATA {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_GETSETBUSDATA").field("BusDataType", &self.BusDataType).field("BusNumber", &self.BusNumber).field("SlotNumber", &self.SlotNumber).field("Buffer", &self.Buffer).field("Offset", &self.Offset).field("Length", &self.Length).finish()
}
}
impl ::core::cmp::PartialEq for _GETSETBUSDATA {
fn eq(&self, other: &Self) -> bool {
self.BusDataType == other.BusDataType && self.BusNumber == other.BusNumber && self.SlotNumber == other.SlotNumber && self.Buffer == other.Buffer && self.Offset == other.Offset && self.Length == other.Length
}
}
impl ::core::cmp::Eq for _GETSETBUSDATA {}
unsafe impl ::windows::core::Abi for _GETSETBUSDATA {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct _IMAGEHLP_JIT_SYMBOL_MAP {
pub SizeOfStruct: u32,
pub Address: u64,
pub BaseOfImage: u64,
}
impl _IMAGEHLP_JIT_SYMBOL_MAP {}
impl ::core::default::Default for _IMAGEHLP_JIT_SYMBOL_MAP {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for _IMAGEHLP_JIT_SYMBOL_MAP {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_IMAGEHLP_JIT_SYMBOL_MAP").field("SizeOfStruct", &self.SizeOfStruct).field("Address", &self.Address).field("BaseOfImage", &self.BaseOfImage).finish()
}
}
impl ::core::cmp::PartialEq for _IMAGEHLP_JIT_SYMBOL_MAP {
fn eq(&self, other: &Self) -> bool {
self.SizeOfStruct == other.SizeOfStruct && self.Address == other.Address && self.BaseOfImage == other.BaseOfImage
}
}
impl ::core::cmp::Eq for _IMAGEHLP_JIT_SYMBOL_MAP {}
unsafe impl ::windows::core::Abi for _IMAGEHLP_JIT_SYMBOL_MAP {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {
pub InstructionOffset: u64,
pub ReturnOffset: u64,
pub FrameOffset: u64,
pub StackOffset: u64,
}
impl __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {}
impl ::core::default::Default for __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("__MIDL___MIDL_itf_jscript9diag_0000_0007_0001").field("InstructionOffset", &self.InstructionOffset).field("ReturnOffset", &self.ReturnOffset).field("FrameOffset", &self.FrameOffset).field("StackOffset", &self.StackOffset).finish()
}
}
impl ::core::cmp::PartialEq for __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {
fn eq(&self, other: &Self) -> bool {
self.InstructionOffset == other.InstructionOffset && self.ReturnOffset == other.ReturnOffset && self.FrameOffset == other.FrameOffset && self.StackOffset == other.StackOffset
}
}
impl ::core::cmp::Eq for __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {}
unsafe impl ::windows::core::Abi for __MIDL___MIDL_itf_jscript9diag_0000_0007_0001 {
type Abi = Self;
}
pub const fasaCaseSensitive: u32 = 4u32;
pub const fasaPreferInternalHandler: u32 = 1u32;
pub const fasaSupportInternalHandler: u32 = 2u32;
pub const sevMax: i32 = 4i32;
|
extern crate peg;
use itertools::Itertools;
use std::collections::HashMap;
use std::ops;
#[derive(PartialEq, Eq, Hash, Debug, Copy, Clone)]
pub struct Hex {
x: i32,
y: i32,
}
impl Hex {
pub fn new(x: i32, y: i32) -> Hex {
Hex { x, y }
}
pub fn neighbours(&self) -> Vec<Hex> {
vec![
*self + Hex::new(1, 0),
*self + Hex::new(0, 1),
*self + Hex::new(-1, 1),
*self + Hex::new(-1, 0),
*self + Hex::new(0, -1),
*self + Hex::new(1, -1),
]
}
}
impl ops::Add<Hex> for Hex {
type Output = Hex;
fn add(self, _rhs: Hex) -> Hex {
Hex::new(self.x + _rhs.x, self.y + _rhs.y)
}
}
impl ops::Add<&Hex> for Hex {
type Output = Hex;
fn add(self, _rhs: &Hex) -> Hex {
Hex::new(self.x + _rhs.x, self.y + _rhs.y)
}
}
// pub type Hex = (i32, i32);
peg::parser! {
grammar instructions_parser() for str {
rule east() -> Hex
= "e" { Hex::new(1, 0) }
rule south_east() -> Hex
= "se" { Hex::new(0, 1) }
rule south_west() -> Hex
= "sw" { Hex::new(-1, 1) }
rule west() -> Hex
= "w" { Hex::new(-1, 0) }
rule north_west() -> Hex
= "nw" { Hex::new(0, -1) }
rule north_east() -> Hex
= "ne" { Hex::new(1, -1)}
pub rule item() -> Hex
= n: (east() / south_east() / south_west() / west() / north_west() / north_east()) {
n
}
pub rule row() -> Vec<Hex>
= row:item() * {
row
}
}
}
pub fn run() {
let mut tiles: HashMap<Hex, u32> = HashMap::new();
include_str!("../day24.txt").split("\n").for_each(|line| {
let tile0: Hex = Hex::new(0, 0);
let dst_tile = instructions_parser::row(line)
.ok()
.unwrap()
.iter()
.fold(tile0, |acc, step| acc + step);
*tiles.entry(dst_tile).or_insert(0) += 1;
});
let count = tiles.values().filter(|&&v| v % 2 == 1).count();
println!("{}", count);
for i in 1..101 {
let mut new_tiles: HashMap<Hex, u32> = HashMap::new();
// println!("size {}", tiles.len());
tiles
.keys()
.flat_map(|&v| v.neighbours().into_iter())
.unique()
.for_each(|t| {
let is_black = tiles.get(&t).unwrap_or(&0) % 2 == 1;
let black_neighbours = t
.neighbours()
.iter()
.filter(|&t| tiles.get(t).unwrap_or(&0) % 2 == 1)
.count();
// println!("BLACK {} {}", is_black, black_neighbours);
if is_black && (black_neighbours == 0 || black_neighbours > 2) {
new_tiles.insert(t, 0);
} else if !is_black && black_neighbours == 2 {
new_tiles.insert(t, 1);
} else {
let v = if is_black { 1 } else { 0 };
new_tiles.insert(t, v);
}
});
tiles = new_tiles;
}
let count = tiles.values().filter(|&&v| v % 2 == 1).count();
println!("{}", count);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_tile_() {
let tile: Vec<Hex> = instructions_parser::row("e").ok().unwrap();
assert_eq!(1, tile.len());
assert_eq!(1, tile.get(0).unwrap().x);
assert_eq!(0, tile.get(0).unwrap().y);
println!("{:?}", tile);
}
#[test]
fn test_tile2() {
let tile: Vec<Hex> = instructions_parser::row("sweswneswswswswwswswswseneswswnwswwne")
.ok()
.unwrap();
// assert_eq!(1, tile.len());
// assert_eq!(1, tile.get(0).unwrap().0);
// assert_eq!(0, tile.get(0).unwrap().1);
println!("{:?}", tile);
}
}
|
use gatt::characteristics as ch;
use gatt::services as srv;
use gatt::{CharacteristicProperties, Registration};
pub(crate) fn add(registration: &mut Registration<super::Token>) {
registration.add_primary_service(srv::BATTERY);
registration.add_characteristic(
ch::BATTERY_LEVEL,
vec![100],
CharacteristicProperties::INDICATE,
);
}
|
use std::marker::PhantomData;
use crate::{
type_level::impl_enum::{Implemented, Unimplemented},
GetStaticEquivalent, InterfaceType, StableAbi,
};
use core_extensions::type_asserts::AssertEq;
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(StableAbi)]
#[sabi(impl_InterfaceType(
Send,
Sync,
Unpin,
Clone,
Default,
Display,
Debug,
Serialize,
Deserialize,
Eq,
PartialEq,
Ord,
PartialOrd,
Hash,
Iterator,
DoubleEndedIterator,
FmtWrite,
IoWrite,
IoSeek,
IoRead,
IoBufRead,
Error
))]
pub struct AllTraitsImpld;
#[test]
fn assert_all_traits_impld() {
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Send, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Sync, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Unpin, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Clone, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Default, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Display, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Debug, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Serialize, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Deserialize, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Eq, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::PartialEq, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Ord, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::PartialOrd, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Hash, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Iterator, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::DoubleEndedIterator, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::FmtWrite, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::IoWrite, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::IoSeek, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::IoRead, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::IoBufRead, Implemented<_>>;
let _: AssertEq<<AllTraitsImpld as InterfaceType>::Error, Implemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(StableAbi)]
// #[sabi(debug_print)]
#[sabi(impl_InterfaceType())]
pub struct NoTraitsImpld<T>(PhantomData<T>);
#[test]
fn assert_all_traits_unimpld() {
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::PartialEq, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<NoTraitsImpld<()> as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(Debug, Display))]
pub struct FmtInterface<T>(PhantomData<T>)
where
T: std::fmt::Debug;
#[test]
fn assert_fmt_traits_impld() {
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Display, Implemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Debug, Implemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::PartialEq, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<FmtInterface<()> as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(Hash, Ord))]
pub struct HashOrdInterface<T>(PhantomData<T>)
where
T: std::fmt::Debug;
#[test]
fn assert_hash_ord_impld() {
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Eq, Implemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::PartialEq, Implemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Ord, Implemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::PartialOrd, Implemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Hash, Implemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<
<HashOrdInterface<()> as InterfaceType>::DoubleEndedIterator,
Unimplemented<_>,
>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<HashOrdInterface<()> as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(Eq))]
pub struct OnlyEq;
#[test]
fn assert_only_eq() {
let _: AssertEq<<OnlyEq as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Eq, Implemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::PartialEq, Implemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<OnlyEq as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(PartialOrd))]
pub struct OnlyPartialOrd;
#[test]
fn assert_only_partial_ord() {
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::PartialEq, Implemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::PartialOrd, Implemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<OnlyPartialOrd as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(Error))]
pub struct OnlyError;
#[test]
fn assert_only_error() {
let _: AssertEq<<OnlyError as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Display, Implemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Debug, Implemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::PartialEq, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Iterator, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<OnlyError as InterfaceType>::Error, Implemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(Iterator))]
pub struct OnlyIter;
#[test]
fn assert_only_iter() {
let _: AssertEq<<OnlyIter as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::PartialEq, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Iterator, Implemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::DoubleEndedIterator, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<OnlyIter as InterfaceType>::Error, Unimplemented<_>>;
}
////////////////////////////////////////////////////////////////////////////////
#[repr(C)]
#[derive(GetStaticEquivalent)]
#[sabi(impl_InterfaceType(DoubleEndedIterator))]
pub struct OnlyDEIter;
#[test]
fn assert_only_de_iter() {
let _: AssertEq<<OnlyDEIter as InterfaceType>::Send, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Sync, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Unpin, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Clone, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Default, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Display, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Debug, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Serialize, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Deserialize, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Eq, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::PartialEq, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Ord, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::PartialOrd, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Hash, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Iterator, Implemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::DoubleEndedIterator, Implemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::FmtWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::IoWrite, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::IoSeek, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::IoRead, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::IoBufRead, Unimplemented<_>>;
let _: AssertEq<<OnlyDEIter as InterfaceType>::Error, Unimplemented<_>>;
}
|
mod helloworld;
pub fn main() {
yew::Renderer::<helloworld::App>::new().render();
}
|
#[doc = "Reader of register SECSR"]
pub type R = crate::R<u32, super::SECSR>;
#[doc = "Writer for register SECSR"]
pub type W = crate::W<u32, super::SECSR>;
#[doc = "Register SECSR `reset()`'s with value 0"]
impl crate::ResetValue for super::SECSR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `RMVFSECF`"]
pub type RMVFSECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RMVFSECF`"]
pub struct RMVFSECF_W<'a> {
w: &'a mut W,
}
impl<'a> RMVFSECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `HSI48SECF`"]
pub type HSI48SECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HSI48SECF`"]
pub struct HSI48SECF_W<'a> {
w: &'a mut W,
}
impl<'a> HSI48SECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `CLK48MSECF`"]
pub type CLK48MSECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `CLK48MSECF`"]
pub struct CLK48MSECF_W<'a> {
w: &'a mut W,
}
impl<'a> CLK48MSECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `PLLSAI2SECF`"]
pub type PLLSAI2SECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PLLSAI2SECF`"]
pub struct PLLSAI2SECF_W<'a> {
w: &'a mut W,
}
impl<'a> PLLSAI2SECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `PLLSAI1SECF`"]
pub type PLLSAI1SECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PLLSAI1SECF`"]
pub struct PLLSAI1SECF_W<'a> {
w: &'a mut W,
}
impl<'a> PLLSAI1SECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `PLLSECF`"]
pub type PLLSECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PLLSECF`"]
pub struct PLLSECF_W<'a> {
w: &'a mut W,
}
impl<'a> PLLSECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `PRESCSECF`"]
pub type PRESCSECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `PRESCSECF`"]
pub struct PRESCSECF_W<'a> {
w: &'a mut W,
}
impl<'a> PRESCSECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `SYSCLKSECF`"]
pub type SYSCLKSECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SYSCLKSECF`"]
pub struct SYSCLKSECF_W<'a> {
w: &'a mut W,
}
impl<'a> SYSCLKSECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `LSESECF`"]
pub type LSESECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LSESECF`"]
pub struct LSESECF_W<'a> {
w: &'a mut W,
}
impl<'a> LSESECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `LSISECF`"]
pub type LSISECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LSISECF`"]
pub struct LSISECF_W<'a> {
w: &'a mut W,
}
impl<'a> LSISECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `MSISECF`"]
pub type MSISECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `MSISECF`"]
pub struct MSISECF_W<'a> {
w: &'a mut W,
}
impl<'a> MSISECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `HSESECF`"]
pub type HSESECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HSESECF`"]
pub struct HSESECF_W<'a> {
w: &'a mut W,
}
impl<'a> HSESECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `HSISECF`"]
pub type HSISECF_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HSISECF`"]
pub struct HSISECF_W<'a> {
w: &'a mut W,
}
impl<'a> HSISECF_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
impl R {
#[doc = "Bit 12 - RMVFSECF"]
#[inline(always)]
pub fn rmvfsecf(&self) -> RMVFSECF_R {
RMVFSECF_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 11 - HSI48SECF"]
#[inline(always)]
pub fn hsi48secf(&self) -> HSI48SECF_R {
HSI48SECF_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - CLK48MSECF"]
#[inline(always)]
pub fn clk48msecf(&self) -> CLK48MSECF_R {
CLK48MSECF_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - PLLSAI2SECF"]
#[inline(always)]
pub fn pllsai2secf(&self) -> PLLSAI2SECF_R {
PLLSAI2SECF_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - PLLSAI1SECF"]
#[inline(always)]
pub fn pllsai1secf(&self) -> PLLSAI1SECF_R {
PLLSAI1SECF_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - PLLSECF"]
#[inline(always)]
pub fn pllsecf(&self) -> PLLSECF_R {
PLLSECF_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - PRESCSECF"]
#[inline(always)]
pub fn prescsecf(&self) -> PRESCSECF_R {
PRESCSECF_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - SYSCLKSECF"]
#[inline(always)]
pub fn sysclksecf(&self) -> SYSCLKSECF_R {
SYSCLKSECF_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - LSESECF"]
#[inline(always)]
pub fn lsesecf(&self) -> LSESECF_R {
LSESECF_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - LSISECF"]
#[inline(always)]
pub fn lsisecf(&self) -> LSISECF_R {
LSISECF_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - MSISECF"]
#[inline(always)]
pub fn msisecf(&self) -> MSISECF_R {
MSISECF_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - HSESECF"]
#[inline(always)]
pub fn hsesecf(&self) -> HSESECF_R {
HSESECF_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - HSISECF"]
#[inline(always)]
pub fn hsisecf(&self) -> HSISECF_R {
HSISECF_R::new((self.bits & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 12 - RMVFSECF"]
#[inline(always)]
pub fn rmvfsecf(&mut self) -> RMVFSECF_W {
RMVFSECF_W { w: self }
}
#[doc = "Bit 11 - HSI48SECF"]
#[inline(always)]
pub fn hsi48secf(&mut self) -> HSI48SECF_W {
HSI48SECF_W { w: self }
}
#[doc = "Bit 10 - CLK48MSECF"]
#[inline(always)]
pub fn clk48msecf(&mut self) -> CLK48MSECF_W {
CLK48MSECF_W { w: self }
}
#[doc = "Bit 9 - PLLSAI2SECF"]
#[inline(always)]
pub fn pllsai2secf(&mut self) -> PLLSAI2SECF_W {
PLLSAI2SECF_W { w: self }
}
#[doc = "Bit 8 - PLLSAI1SECF"]
#[inline(always)]
pub fn pllsai1secf(&mut self) -> PLLSAI1SECF_W {
PLLSAI1SECF_W { w: self }
}
#[doc = "Bit 7 - PLLSECF"]
#[inline(always)]
pub fn pllsecf(&mut self) -> PLLSECF_W {
PLLSECF_W { w: self }
}
#[doc = "Bit 6 - PRESCSECF"]
#[inline(always)]
pub fn prescsecf(&mut self) -> PRESCSECF_W {
PRESCSECF_W { w: self }
}
#[doc = "Bit 5 - SYSCLKSECF"]
#[inline(always)]
pub fn sysclksecf(&mut self) -> SYSCLKSECF_W {
SYSCLKSECF_W { w: self }
}
#[doc = "Bit 4 - LSESECF"]
#[inline(always)]
pub fn lsesecf(&mut self) -> LSESECF_W {
LSESECF_W { w: self }
}
#[doc = "Bit 3 - LSISECF"]
#[inline(always)]
pub fn lsisecf(&mut self) -> LSISECF_W {
LSISECF_W { w: self }
}
#[doc = "Bit 2 - MSISECF"]
#[inline(always)]
pub fn msisecf(&mut self) -> MSISECF_W {
MSISECF_W { w: self }
}
#[doc = "Bit 1 - HSESECF"]
#[inline(always)]
pub fn hsesecf(&mut self) -> HSESECF_W {
HSESECF_W { w: self }
}
#[doc = "Bit 0 - HSISECF"]
#[inline(always)]
pub fn hsisecf(&mut self) -> HSISECF_W {
HSISECF_W { w: self }
}
}
|
// auto generated, do not modify.
// created: Wed Jan 20 00:44:03 2016
// src-file: /QtQml/qqmldebug.h
// dst-file: /src/qml/qqmldebug.rs
//
// header block begin =>
#![feature(libc)]
#![feature(core)]
#![feature(collections)]
extern crate libc;
use self::libc::*;
// <= header block end
// main block begin =>
// <= main block end
// use block begin =>
use std::ops::Deref;
use super::super::core::qstring::QString; // 771
// <= use block end
// ext block begin =>
// #[link(name = "Qt5Core")]
// #[link(name = "Qt5Gui")]
// #[link(name = "Qt5Widgets")]
// #[link(name = "QtInline")]
extern {
fn QQmlDebuggingEnabler_Class_Size() -> c_int;
// proto: void QQmlDebuggingEnabler::QQmlDebuggingEnabler(bool printWarning);
fn _ZN20QQmlDebuggingEnablerC2Eb(qthis: u64 /* *mut c_void*/, arg0: c_char);
} // <= ext block end
// body block begin =>
// class sizeof(QQmlDebuggingEnabler)=1
#[derive(Default)]
pub struct QQmlDebuggingEnabler {
// qbase: None,
pub qclsinst: u64 /* *mut c_void*/,
}
impl /*struct*/ QQmlDebuggingEnabler {
pub fn inheritFrom(qthis: u64 /* *mut c_void*/) -> QQmlDebuggingEnabler {
return QQmlDebuggingEnabler{qclsinst: qthis, ..Default::default()};
}
}
// proto: void QQmlDebuggingEnabler::QQmlDebuggingEnabler(bool printWarning);
impl /*struct*/ QQmlDebuggingEnabler {
pub fn new<T: QQmlDebuggingEnabler_new>(value: T) -> QQmlDebuggingEnabler {
let rsthis = value.new();
return rsthis;
// return 1;
}
}
pub trait QQmlDebuggingEnabler_new {
fn new(self) -> QQmlDebuggingEnabler;
}
// proto: void QQmlDebuggingEnabler::QQmlDebuggingEnabler(bool printWarning);
impl<'a> /*trait*/ QQmlDebuggingEnabler_new for (i8) {
fn new(self) -> QQmlDebuggingEnabler {
// let qthis: *mut c_void = unsafe{calloc(1, 32)};
// unsafe{_ZN20QQmlDebuggingEnablerC2Eb()};
let ctysz: c_int = unsafe{QQmlDebuggingEnabler_Class_Size()};
let qthis_ph: u64 = unsafe{calloc(1, ctysz as usize)} as u64;
let arg0 = self as c_char;
unsafe {_ZN20QQmlDebuggingEnablerC2Eb(qthis_ph, arg0)};
let qthis: u64 = qthis_ph;
let rsthis = QQmlDebuggingEnabler{qclsinst: qthis, ..Default::default()};
return rsthis;
// return 1;
}
}
// <= body block end
|
use chrono::Utc;
use serde::{Deserialize, Serialize};
use sqlx::types::chrono::DateTime;
#[derive(Serialize, Deserialize, Debug)]
pub struct Expedition {
pub id: i64,
pub url: String,
pub name: String,
pub start: DateTime<Utc>,
pub end: Option<DateTime<Utc>>,
}
|
use crate::debug::DebugState;
use cvar::{INode, IVisit};
pub use soldank_shared::cvars::*;
#[derive(Default)]
pub struct Config {
pub phys: Physics,
pub net: NetConfig,
pub debug: DebugState,
}
impl IVisit for Config {
fn visit(&mut self, f: &mut dyn FnMut(&mut dyn INode)) {
f(&mut cvar::List("net", &mut self.net));
f(&mut cvar::List("phys", &mut self.phys));
f(&mut cvar::List("debug", &mut self.debug));
}
}
|
#[no_mangle]
#[inline(never)]
pub fn sm_alloc(size: i32) -> i64 {
let layout = std::alloc::Layout::from_size_align(size as usize, 4).unwrap();
let ptr = unsafe { std::alloc::alloc(layout) };
ptr as i64
}
|
use core::fmt;
use crate::config::{ Configuration, auto_retransmit, auto_ack };
use crate::device::{ Device, UsingDevice };
use crate::rx::RxMode;
use crate::tx::TxMode;
use crate::ptx::PtxMode;
use crate::registers::{ Feature, Dynpd };
use crate::PIPES_COUNT;
/// Represents **Standby-I** mode
///
/// This represents the state the device is in inbetween TX or RX
/// mode.
pub struct StandbyMode<D: Device> {
device: D,
}
impl<D: Device> fmt::Debug for StandbyMode<D> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "StandbyMode")
}
}
impl<D: Device> UsingDevice<D> for StandbyMode<D> {
fn device(&mut self) -> &mut D {
&mut self.device
}
}
impl<D: Device> Configuration<D> for StandbyMode<D> {
}
impl<D: Device> StandbyMode<D> {
/// Constructor
///
/// Puts the `device` into standy mode
pub fn power_up(mut device: D) -> Result<Self, (D, D::Error)> {
match device.update_config(|config| config.set_pwr_up(true)) {
Ok(()) => Ok(StandbyMode { device }),
Err(e) => Err((device, e)),
}
}
/// Should be a no-op
pub fn power_down(mut self) -> Result<D, (Self, D::Error)> {
match self.device.update_config(|config| config.set_pwr_up(false)) {
Ok(()) => Ok(self.device),
Err(e) => Err((self, e)),
}
}
pub(crate) fn from_rx_tx(mut device: D) -> Self {
device.ce_disable();
StandbyMode { device }
}
/// Go into RX mode
pub fn rx(self) -> Result<RxMode<D>, (D, D::Error)> {
let mut device = self.device;
match device.update_config(|config| config.set_prim_rx(true)) {
Ok(()) => {
device.ce_enable();
Ok(RxMode::new(device))
}
Err(e) => Err((device, e)),
}
}
/// Go into TX mode
pub fn tx(self) -> Result<TxMode<D>, (D, D::Error)> {
let mut device = self.device;
match device.update_config(|config| config.set_prim_rx(false)) {
Ok(()) => {
// No need to device.ce_enable(); yet
Ok(TxMode::new(device))
}
Err(e) => Err((device, e)),
}
}
/// Enter PTX mode.
pub fn ptx(self, delay: u8, retries: u8) -> Result<PtxMode<D>, (D, D::Error)> {
let mut device = self.device;
let mut config_ptx = || {
device.write_register(auto_ack(&[ true; 6 ]))?;
device.write_register(auto_retransmit(delay, retries))?;
// Enable ack payload and dynamic payload features
device.update_register::<Feature, _, _>(|feature| {
feature.set_en_ack_pay(true);
feature.set_en_dpl(true);
})?;
// Enable dynamic payload on all pipes
device.write_register(Dynpd::from_bools(&[true; PIPES_COUNT]))?;
Ok(())
};
match config_ptx() {
Ok(()) => {
match device.update_config(|config| config.set_prim_rx(false)) {
Ok(()) => {
// No need to device.ce_enable(); yet
Ok(PtxMode::new(device))
}
Err(e) => Err((device, e)),
}
},
Err(e) => Err((device, e))
}
}
}
|
#[doc = r" Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r" Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::PATCHEN {
#[doc = r" Modifies the contents of the register"]
#[inline]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
let r = R { bits: bits };
let mut w = W { bits: bits };
f(&r, &mut w);
self.register.set(w.bits);
}
#[doc = r" Reads the contents of the register"]
#[inline]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r" Writes to the register"]
#[inline]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
let mut w = W::reset_value();
f(&mut w);
self.register.set(w.bits);
}
#[doc = r" Writes the reset value to the register"]
#[inline]
pub fn reset(&self) {
self.write(|w| w)
}
}
#[doc = "Possible values of the field `PATCH0`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH0R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH0R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH0R::DISABLED => false,
PATCH0R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH0R {
match value {
false => PATCH0R::DISABLED,
true => PATCH0R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH0R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH0R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH1`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH1R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH1R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH1R::DISABLED => false,
PATCH1R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH1R {
match value {
false => PATCH1R::DISABLED,
true => PATCH1R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH1R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH1R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH2`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH2R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH2R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH2R::DISABLED => false,
PATCH2R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH2R {
match value {
false => PATCH2R::DISABLED,
true => PATCH2R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH2R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH2R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH3`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH3R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH3R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH3R::DISABLED => false,
PATCH3R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH3R {
match value {
false => PATCH3R::DISABLED,
true => PATCH3R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH3R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH3R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH4`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH4R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH4R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH4R::DISABLED => false,
PATCH4R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH4R {
match value {
false => PATCH4R::DISABLED,
true => PATCH4R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH4R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH4R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH5`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH5R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH5R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH5R::DISABLED => false,
PATCH5R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH5R {
match value {
false => PATCH5R::DISABLED,
true => PATCH5R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH5R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH5R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH6`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH6R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH6R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH6R::DISABLED => false,
PATCH6R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH6R {
match value {
false => PATCH6R::DISABLED,
true => PATCH6R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH6R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH6R::ENABLED
}
}
#[doc = "Possible values of the field `PATCH7`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PATCH7R {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH7R {
#[doc = r" Returns `true` if the bit is clear (0)"]
#[inline]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r" Returns `true` if the bit is set (1)"]
#[inline]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r" Value of the field as raw bits"]
#[inline]
pub fn bit(&self) -> bool {
match *self {
PATCH7R::DISABLED => false,
PATCH7R::ENABLED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _from(value: bool) -> PATCH7R {
match value {
false => PATCH7R::DISABLED,
true => PATCH7R::ENABLED,
}
}
#[doc = "Checks if the value of the field is `DISABLED`"]
#[inline]
pub fn is_disabled(&self) -> bool {
*self == PATCH7R::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == PATCH7R::ENABLED
}
}
#[doc = "Values that can be written to the field `PATCH0`"]
pub enum PATCH0W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH0W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH0W::DISABLED => false,
PATCH0W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH0W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH0W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH0W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH0W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH0W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 0;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH1`"]
pub enum PATCH1W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH1W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH1W::DISABLED => false,
PATCH1W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH1W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH1W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH1W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH1W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH1W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 1;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH2`"]
pub enum PATCH2W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH2W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH2W::DISABLED => false,
PATCH2W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH2W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH2W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH2W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH2W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH2W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 2;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH3`"]
pub enum PATCH3W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH3W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH3W::DISABLED => false,
PATCH3W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH3W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH3W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH3W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH3W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH3W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 3;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH4`"]
pub enum PATCH4W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH4W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH4W::DISABLED => false,
PATCH4W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH4W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH4W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH4W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH4W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH4W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 4;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH5`"]
pub enum PATCH5W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH5W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH5W::DISABLED => false,
PATCH5W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH5W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH5W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH5W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH5W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH5W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 5;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH6`"]
pub enum PATCH6W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH6W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH6W::DISABLED => false,
PATCH6W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH6W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH6W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH6W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH6W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH6W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 6;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
#[doc = "Values that can be written to the field `PATCH7`"]
pub enum PATCH7W {
#[doc = "Patch disabled."]
DISABLED,
#[doc = "Patch enabled."]
ENABLED,
}
impl PATCH7W {
#[allow(missing_docs)]
#[doc(hidden)]
#[inline]
pub fn _bits(&self) -> bool {
match *self {
PATCH7W::DISABLED => false,
PATCH7W::ENABLED => true,
}
}
}
#[doc = r" Proxy"]
pub struct _PATCH7W<'a> {
w: &'a mut W,
}
impl<'a> _PATCH7W<'a> {
#[doc = r" Writes `variant` to the field"]
#[inline]
pub fn variant(self, variant: PATCH7W) -> &'a mut W {
{
self.bit(variant._bits())
}
}
#[doc = "Patch disabled."]
#[inline]
pub fn disabled(self) -> &'a mut W {
self.variant(PATCH7W::DISABLED)
}
#[doc = "Patch enabled."]
#[inline]
pub fn enabled(self) -> &'a mut W {
self.variant(PATCH7W::ENABLED)
}
#[doc = r" Sets the field bit"]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r" Clears the field bit"]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r" Writes raw bits to the field"]
#[inline]
pub fn bit(self, value: bool) -> &'a mut W {
const MASK: bool = true;
const OFFSET: u8 = 7;
self.w.bits &= !((MASK as u32) << OFFSET);
self.w.bits |= ((value & MASK) as u32) << OFFSET;
self.w
}
}
impl R {
#[doc = r" Value of the register as raw bits"]
#[inline]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Patch 0 enabled."]
#[inline]
pub fn patch0(&self) -> PATCH0R {
PATCH0R::_from({
const MASK: bool = true;
const OFFSET: u8 = 0;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 1 - Patch 1 enabled."]
#[inline]
pub fn patch1(&self) -> PATCH1R {
PATCH1R::_from({
const MASK: bool = true;
const OFFSET: u8 = 1;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 2 - Patch 2 enabled."]
#[inline]
pub fn patch2(&self) -> PATCH2R {
PATCH2R::_from({
const MASK: bool = true;
const OFFSET: u8 = 2;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 3 - Patch 3 enabled."]
#[inline]
pub fn patch3(&self) -> PATCH3R {
PATCH3R::_from({
const MASK: bool = true;
const OFFSET: u8 = 3;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 4 - Patch 4 enabled."]
#[inline]
pub fn patch4(&self) -> PATCH4R {
PATCH4R::_from({
const MASK: bool = true;
const OFFSET: u8 = 4;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 5 - Patch 5 enabled."]
#[inline]
pub fn patch5(&self) -> PATCH5R {
PATCH5R::_from({
const MASK: bool = true;
const OFFSET: u8 = 5;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 6 - Patch 6 enabled."]
#[inline]
pub fn patch6(&self) -> PATCH6R {
PATCH6R::_from({
const MASK: bool = true;
const OFFSET: u8 = 6;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
#[doc = "Bit 7 - Patch 7 enabled."]
#[inline]
pub fn patch7(&self) -> PATCH7R {
PATCH7R::_from({
const MASK: bool = true;
const OFFSET: u8 = 7;
((self.bits >> OFFSET) & MASK as u32) != 0
})
}
}
impl W {
#[doc = r" Reset value of the register"]
#[inline]
pub fn reset_value() -> W {
W { bits: 0 }
}
#[doc = r" Writes raw bits to the register"]
#[inline]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - Patch 0 enabled."]
#[inline]
pub fn patch0(&mut self) -> _PATCH0W {
_PATCH0W { w: self }
}
#[doc = "Bit 1 - Patch 1 enabled."]
#[inline]
pub fn patch1(&mut self) -> _PATCH1W {
_PATCH1W { w: self }
}
#[doc = "Bit 2 - Patch 2 enabled."]
#[inline]
pub fn patch2(&mut self) -> _PATCH2W {
_PATCH2W { w: self }
}
#[doc = "Bit 3 - Patch 3 enabled."]
#[inline]
pub fn patch3(&mut self) -> _PATCH3W {
_PATCH3W { w: self }
}
#[doc = "Bit 4 - Patch 4 enabled."]
#[inline]
pub fn patch4(&mut self) -> _PATCH4W {
_PATCH4W { w: self }
}
#[doc = "Bit 5 - Patch 5 enabled."]
#[inline]
pub fn patch5(&mut self) -> _PATCH5W {
_PATCH5W { w: self }
}
#[doc = "Bit 6 - Patch 6 enabled."]
#[inline]
pub fn patch6(&mut self) -> _PATCH6W {
_PATCH6W { w: self }
}
#[doc = "Bit 7 - Patch 7 enabled."]
#[inline]
pub fn patch7(&mut self) -> _PATCH7W {
_PATCH7W { w: self }
}
}
|
use fltk::{prelude::*, *};
use fltk_flex::Flex;
fn main() {
let a = app::App::default().with_scheme(app::Scheme::Gtk);
let mut win = window::Window::default().with_size(640, 480);
let mut col = Flex::new(5, 5, 630, 470, None).column();
{
let mut row = Flex::default().row();
{
let _cancel = create_button("Cancel");
let frame = frame::Frame::default().with_label("Box");
let _ok = create_button("OK");
let _input = input::Input::default();
let col2 = Flex::default().column();
{
let top = create_button("Top");
col2.resizable(&top);
let _bottom = create_button("Bottom");
col2.end();
}
row.resizable(&frame);
row.end();
}
col.set_size(&mut create_middle(), 30);
let _ub1 = create_button("Something1");
row = Flex::default().row();
{
let mut cancel = create_button("Cancel");
let mut ok = create_button("OK");
let _input = input::Input::default();
row.set_size(&mut cancel, 100);
row.set_size(&mut ok, 100);
row.end();
}
let _ub2 = create_button("Something2");
col.set_size(&mut row, 30);
col.end();
}
win.resizable(&col);
win.end();
win.show();
a.run().unwrap();
}
fn create_middle() -> Flex {
let mut row = Flex::default().row();
{
let _cancel = create_button("Cancel");
let mut frame = frame::Frame::default().with_label("Box");
let _ok = create_button("OK");
let _input = input::Input::default();
let mut col2 = Flex::default().column();
{
create_button("Top");
col2.end();
}
row.set_size(&mut frame, 30);
row.set_size(&mut col2, 100);
row.end();
}
row
}
fn create_button(caption: &str) -> button::Button {
let mut btn = button::Button::default()
.with_label(caption);
btn.set_color(enums::Color::from_rgb(225, 225, 225));
btn
}
|
//Definition for singly-linked list.
#[derive(PartialEq, Eq, Debug)]
pub struct ListNode {
pub val: i32,
pub next: Option<Box<ListNode>>,
}
impl ListNode {
#[inline]
fn new(val: i32) -> Self {
ListNode { next: None, val }
}
}
struct Solution {}
// ๅๅนถ k ไธชๆๅบ้พ่กจ๏ผ่ฟๅๅๅนถๅ็ๆๅบ้พ่กจใ่ฏทๅๆๅๆ่ฟฐ็ฎๆณ็ๅคๆๅบฆใ
//
//็คบไพ:
//
//่พๅ
ฅ:
//[
// 1->4->5,
// 1->3->4,
// 2->6
//]
//่พๅบ: 1->1->2->3->4->4->5->6
impl Solution {
pub fn merge_k_lists(lists: Vec<Option<Box<ListNode>>>) -> Option<Box<ListNode>> {
let mut r: Vec<i32> = lists
.iter()
.map(|it| {
fn list_node_to_vec(node: &Option<Box<ListNode>>) -> Vec<i32> {
match node {
Some(node) => {
let mut v = list_node_to_vec(&node.next);
v.push(node.val);
v
}
None => Vec::new(),
}
}
list_node_to_vec(it)
})
.flat_map(|it| Vec::into_iter(it))
.collect();
fn vec_to_list_node(mut v: Vec<i32>) -> Option<Box<ListNode>> {
let mut res: Option<Box<ListNode>> = Option::None;
while !v.is_empty() {
let mut temp = ListNode::new(v.pop().unwrap());
temp.next = res;
res = Option::Some(Box::new(temp));
}
res
}
r.sort();
vec_to_list_node(r)
}
}
fn main() {
let a = Some(Box::new(ListNode::new(21)));
let b = Some(Box::new(ListNode::new(1)));
let c = Some(Box::new(ListNode::new(1)));
let res = Solution::merge_k_lists(vec![a, b, c]);
dbg!(res);
}
|
#[doc = "Reader of register WKUPEPR"]
pub type R = crate::R<u32, super::WKUPEPR>;
#[doc = "Writer for register WKUPEPR"]
pub type W = crate::W<u32, super::WKUPEPR>;
#[doc = "Register WKUPEPR `reset()`'s with value 0"]
impl crate::ResetValue for super::WKUPEPR {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `WKUPEN1`"]
pub type WKUPEN1_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN1`"]
pub struct WKUPEN1_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN1_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `WKUPEN2`"]
pub type WKUPEN2_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN2`"]
pub struct WKUPEN2_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN2_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `WKUPEN3`"]
pub type WKUPEN3_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN3`"]
pub struct WKUPEN3_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN3_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `WKUPEN4`"]
pub type WKUPEN4_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN4`"]
pub struct WKUPEN4_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN4_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `WKUPEN5`"]
pub type WKUPEN5_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN5`"]
pub struct WKUPEN5_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN5_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `WKUPEN6`"]
pub type WKUPEN6_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPEN6`"]
pub struct WKUPEN6_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPEN6_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `WKUPP1`"]
pub type WKUPP1_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP1`"]
pub struct WKUPP1_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP1_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `WKUPP2`"]
pub type WKUPP2_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP2`"]
pub struct WKUPP2_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP2_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `WKUPP3`"]
pub type WKUPP3_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP3`"]
pub struct WKUPP3_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP3_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `WKUPP4`"]
pub type WKUPP4_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP4`"]
pub struct WKUPP4_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP4_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `WKUPP5`"]
pub type WKUPP5_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP5`"]
pub struct WKUPP5_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP5_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `WKUPP6`"]
pub type WKUPP6_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `WKUPP6`"]
pub struct WKUPP6_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPP6_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD1`"]
pub type WKUPPUPD1_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD1`"]
pub struct WKUPPUPD1_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD1_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 16)) | (((value as u32) & 0x03) << 16);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD2`"]
pub type WKUPPUPD2_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD2`"]
pub struct WKUPPUPD2_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD2_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 18)) | (((value as u32) & 0x03) << 18);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD3`"]
pub type WKUPPUPD3_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD3`"]
pub struct WKUPPUPD3_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD3_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 20)) | (((value as u32) & 0x03) << 20);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD4`"]
pub type WKUPPUPD4_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD4`"]
pub struct WKUPPUPD4_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD4_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 22)) | (((value as u32) & 0x03) << 22);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD5`"]
pub type WKUPPUPD5_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD5`"]
pub struct WKUPPUPD5_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD5_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 24)) | (((value as u32) & 0x03) << 24);
self.w
}
}
#[doc = "Reader of field `WKUPPUPD6`"]
pub type WKUPPUPD6_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `WKUPPUPD6`"]
pub struct WKUPPUPD6_W<'a> {
w: &'a mut W,
}
impl<'a> WKUPPUPD6_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 26)) | (((value as u32) & 0x03) << 26);
self.w
}
}
impl R {
#[doc = "Bit 0 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen1(&self) -> WKUPEN1_R {
WKUPEN1_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen2(&self) -> WKUPEN2_R {
WKUPEN2_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen3(&self) -> WKUPEN3_R {
WKUPEN3_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen4(&self) -> WKUPEN4_R {
WKUPEN4_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen5(&self) -> WKUPEN5_R {
WKUPEN5_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen6(&self) -> WKUPEN6_R {
WKUPEN6_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 8 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp1(&self) -> WKUPP1_R {
WKUPP1_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp2(&self) -> WKUPP2_R {
WKUPP2_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp3(&self) -> WKUPP3_R {
WKUPP3_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp4(&self) -> WKUPP4_R {
WKUPP4_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp5(&self) -> WKUPP5_R {
WKUPP5_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 13 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp6(&self) -> WKUPP6_R {
WKUPP6_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bits 16:17 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd1(&self) -> WKUPPUPD1_R {
WKUPPUPD1_R::new(((self.bits >> 16) & 0x03) as u8)
}
#[doc = "Bits 18:19 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd2(&self) -> WKUPPUPD2_R {
WKUPPUPD2_R::new(((self.bits >> 18) & 0x03) as u8)
}
#[doc = "Bits 20:21 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd3(&self) -> WKUPPUPD3_R {
WKUPPUPD3_R::new(((self.bits >> 20) & 0x03) as u8)
}
#[doc = "Bits 22:23 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd4(&self) -> WKUPPUPD4_R {
WKUPPUPD4_R::new(((self.bits >> 22) & 0x03) as u8)
}
#[doc = "Bits 24:25 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd5(&self) -> WKUPPUPD5_R {
WKUPPUPD5_R::new(((self.bits >> 24) & 0x03) as u8)
}
#[doc = "Bits 26:27 - Wakeup pin pull configuration for WKUP(truncate(n/2)-7) These bits define the I/O pad pull configuration used when WKUPEN(truncate(n/2)-7) = 1. The associated GPIO port pull configuration shall be set to the same value or to 00. The Wakeup pin pull configuration is kept in Standby mode."]
#[inline(always)]
pub fn wkuppupd6(&self) -> WKUPPUPD6_R {
WKUPPUPD6_R::new(((self.bits >> 26) & 0x03) as u8)
}
}
impl W {
#[doc = "Bit 0 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen1(&mut self) -> WKUPEN1_W {
WKUPEN1_W { w: self }
}
#[doc = "Bit 1 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen2(&mut self) -> WKUPEN2_W {
WKUPEN2_W { w: self }
}
#[doc = "Bit 2 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen3(&mut self) -> WKUPEN3_W {
WKUPEN3_W { w: self }
}
#[doc = "Bit 3 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen4(&mut self) -> WKUPEN4_W {
WKUPEN4_W { w: self }
}
#[doc = "Bit 4 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen5(&mut self) -> WKUPEN5_W {
WKUPEN5_W { w: self }
}
#[doc = "Bit 5 - Enable Wakeup Pin WKUPn+1 Each bit is set and cleared by software. Note: An additional wakeup event is detected if WKUPn+1 pin is enabled (by setting the WKUPENn+1 bit) when WKUPn+1 pin level is already high when WKUPPn+1 selects rising edge, or low when WKUPPn+1 selects falling edge."]
#[inline(always)]
pub fn wkupen6(&mut self) -> WKUPEN6_W {
WKUPEN6_W { w: self }
}
#[doc = "Bit 8 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp1(&mut self) -> WKUPP1_W {
WKUPP1_W { w: self }
}
#[doc = "Bit 9 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp2(&mut self) -> WKUPP2_W {
WKUPP2_W { w: self }
}
#[doc = "Bit 10 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp3(&mut self) -> WKUPP3_W {
WKUPP3_W { w: self }
}
#[doc = "Bit 11 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp4(&mut self) -> WKUPP4_W {
WKUPP4_W { w: self }
}
#[doc = "Bit 12 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp5(&mut self) -> WKUPP5_W {
WKUPP5_W { w: self }
}
#[doc = "Bit 13 - Wakeup pin polarity bit for WKUPn-7 These bits define the polarity used for event detection on WKUPn-7 external wakeup pin."]
#[inline(always)]
pub fn wkupp6(&mut self) -> WKUPP6_W {
WKUPP6_W { w: self }
}
#[doc = "Bits 16:17 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd1(&mut self) -> WKUPPUPD1_W {
WKUPPUPD1_W { w: self }
}
#[doc = "Bits 18:19 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd2(&mut self) -> WKUPPUPD2_W {
WKUPPUPD2_W { w: self }
}
#[doc = "Bits 20:21 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd3(&mut self) -> WKUPPUPD3_W {
WKUPPUPD3_W { w: self }
}
#[doc = "Bits 22:23 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd4(&mut self) -> WKUPPUPD4_W {
WKUPPUPD4_W { w: self }
}
#[doc = "Bits 24:25 - Wakeup pin pull configuration"]
#[inline(always)]
pub fn wkuppupd5(&mut self) -> WKUPPUPD5_W {
WKUPPUPD5_W { w: self }
}
#[doc = "Bits 26:27 - Wakeup pin pull configuration for WKUP(truncate(n/2)-7) These bits define the I/O pad pull configuration used when WKUPEN(truncate(n/2)-7) = 1. The associated GPIO port pull configuration shall be set to the same value or to 00. The Wakeup pin pull configuration is kept in Standby mode."]
#[inline(always)]
pub fn wkuppupd6(&mut self) -> WKUPPUPD6_W {
WKUPPUPD6_W { w: self }
}
}
|
use super::{
core::{Py, PyObject, PyObjectRef, PyRef},
payload::{PyObjectPayload, PyPayload},
};
use crate::common::{
atomic::{Ordering, PyAtomic, Radium},
lock::PyRwLockReadGuard,
};
use crate::{
builtins::{PyBaseExceptionRef, PyStrInterned, PyType},
convert::{IntoPyException, ToPyObject, ToPyResult, TryFromObject},
vm::Context,
VirtualMachine,
};
use std::{borrow::Borrow, fmt, marker::PhantomData, ops::Deref, ptr::null_mut};
/* Python objects and references.
Okay, so each python object itself is an class itself (PyObject). Each
python object can have several references to it (PyObjectRef). These
references are Rc (reference counting) rust smart pointers. So when
all references are destroyed, the object itself also can be cleaned up.
Basically reference counting, but then done by rust.
*/
/*
* Good reference: https://github.com/ProgVal/pythonvm-rust/blob/master/src/objects/mod.rs
*/
/// Use this type for functions which return a python object or an exception.
/// Both the python object and the python exception are `PyObjectRef` types
/// since exceptions are also python objects.
pub type PyResult<T = PyObjectRef> = Result<T, PyBaseExceptionRef>; // A valid value, or an exception
impl<T: fmt::Display> fmt::Display for PyRef<T>
where
T: PyObjectPayload + fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
impl<T: fmt::Display> fmt::Display for Py<T>
where
T: PyObjectPayload + fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
#[repr(transparent)]
pub struct PyExact<T: PyObjectPayload> {
inner: Py<T>,
}
impl<T: PyPayload> PyExact<T> {
/// # Safety
/// Given reference must be exact type of payload T
#[inline(always)]
pub unsafe fn ref_unchecked(r: &Py<T>) -> &Self {
&*(r as *const _ as *const Self)
}
}
impl<T: PyPayload> Deref for PyExact<T> {
type Target = Py<T>;
#[inline(always)]
fn deref(&self) -> &Py<T> {
&self.inner
}
}
impl<T: PyObjectPayload> Borrow<PyObject> for PyExact<T> {
#[inline(always)]
fn borrow(&self) -> &PyObject {
self.inner.borrow()
}
}
impl<T: PyObjectPayload> AsRef<PyObject> for PyExact<T> {
#[inline(always)]
fn as_ref(&self) -> &PyObject {
self.inner.as_ref()
}
}
impl<T: PyObjectPayload> Borrow<Py<T>> for PyExact<T> {
#[inline(always)]
fn borrow(&self) -> &Py<T> {
&self.inner
}
}
impl<T: PyObjectPayload> AsRef<Py<T>> for PyExact<T> {
#[inline(always)]
fn as_ref(&self) -> &Py<T> {
&self.inner
}
}
impl<T: PyPayload> std::borrow::ToOwned for PyExact<T> {
type Owned = PyRefExact<T>;
fn to_owned(&self) -> Self::Owned {
let owned = self.inner.to_owned();
unsafe { PyRefExact::new_unchecked(owned) }
}
}
impl<T: PyPayload> PyRef<T> {
pub fn into_exact_or(
self,
ctx: &Context,
f: impl FnOnce(Self) -> PyRefExact<T>,
) -> PyRefExact<T> {
if self.class().is(T::class(ctx)) {
unsafe { PyRefExact::new_unchecked(self) }
} else {
f(self)
}
}
}
/// PyRef but guaranteed not to be a subtype instance
#[derive(Debug)]
#[repr(transparent)]
pub struct PyRefExact<T: PyObjectPayload> {
inner: PyRef<T>,
}
impl<T: PyObjectPayload> PyRefExact<T> {
/// # Safety
/// obj must have exact type for the payload
pub unsafe fn new_unchecked(obj: PyRef<T>) -> Self {
Self { inner: obj }
}
pub fn into_pyref(self) -> PyRef<T> {
self.inner
}
}
impl<T: PyObjectPayload> Clone for PyRefExact<T> {
fn clone(&self) -> Self {
let inner = self.inner.clone();
Self { inner }
}
}
impl<T: PyPayload> TryFromObject for PyRefExact<T> {
fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
let target_cls = T::class(&vm.ctx);
let cls = obj.class();
if cls.is(target_cls) {
let obj = obj
.downcast()
.map_err(|obj| vm.new_downcast_runtime_error(target_cls, &obj))?;
Ok(Self { inner: obj })
} else if cls.fast_issubclass(target_cls) {
Err(vm.new_type_error(format!(
"Expected an exact instance of '{}', not a subclass '{}'",
target_cls.name(),
cls.name(),
)))
} else {
Err(vm.new_type_error(format!(
"Expected type '{}', not '{}'",
target_cls.name(),
cls.name(),
)))
}
}
}
impl<T: PyPayload> Deref for PyRefExact<T> {
type Target = PyExact<T>;
#[inline(always)]
fn deref(&self) -> &PyExact<T> {
unsafe { PyExact::ref_unchecked(self.inner.deref()) }
}
}
impl<T: PyObjectPayload> Borrow<PyObject> for PyRefExact<T> {
#[inline(always)]
fn borrow(&self) -> &PyObject {
self.inner.borrow()
}
}
impl<T: PyObjectPayload> AsRef<PyObject> for PyRefExact<T> {
#[inline(always)]
fn as_ref(&self) -> &PyObject {
self.inner.as_ref()
}
}
impl<T: PyObjectPayload> Borrow<Py<T>> for PyRefExact<T> {
#[inline(always)]
fn borrow(&self) -> &Py<T> {
self.inner.borrow()
}
}
impl<T: PyObjectPayload> AsRef<Py<T>> for PyRefExact<T> {
#[inline(always)]
fn as_ref(&self) -> &Py<T> {
self.inner.as_ref()
}
}
impl<T: PyPayload> Borrow<PyExact<T>> for PyRefExact<T> {
#[inline(always)]
fn borrow(&self) -> &PyExact<T> {
self
}
}
impl<T: PyPayload> AsRef<PyExact<T>> for PyRefExact<T> {
#[inline(always)]
fn as_ref(&self) -> &PyExact<T> {
self
}
}
impl<T: PyPayload> ToPyObject for PyRefExact<T> {
#[inline(always)]
fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
self.inner.into()
}
}
pub struct PyAtomicRef<T> {
inner: PyAtomic<*mut u8>,
_phantom: PhantomData<T>,
}
cfg_if::cfg_if! {
if #[cfg(feature = "threading")] {
unsafe impl<T: Send + PyObjectPayload> Send for PyAtomicRef<T> {}
unsafe impl<T: Sync + PyObjectPayload> Sync for PyAtomicRef<T> {}
unsafe impl<T: Send + PyObjectPayload> Send for PyAtomicRef<Option<T>> {}
unsafe impl<T: Sync + PyObjectPayload> Sync for PyAtomicRef<Option<T>> {}
unsafe impl Send for PyAtomicRef<PyObject> {}
unsafe impl Sync for PyAtomicRef<PyObject> {}
unsafe impl Send for PyAtomicRef<Option<PyObject>> {}
unsafe impl Sync for PyAtomicRef<Option<PyObject>> {}
}
}
impl<T: fmt::Debug> fmt::Debug for PyAtomicRef<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "PyAtomicRef(")?;
unsafe {
self.inner
.load(Ordering::Relaxed)
.cast::<T>()
.as_ref()
.fmt(f)
}?;
write!(f, ")")
}
}
impl<T: PyObjectPayload> From<PyRef<T>> for PyAtomicRef<T> {
fn from(pyref: PyRef<T>) -> Self {
let py = PyRef::leak(pyref);
Self {
inner: Radium::new(py as *const _ as *mut _),
_phantom: Default::default(),
}
}
}
impl<T: PyObjectPayload> Deref for PyAtomicRef<T> {
type Target = Py<T>;
fn deref(&self) -> &Self::Target {
unsafe {
self.inner
.load(Ordering::Relaxed)
.cast::<Py<T>>()
.as_ref()
.unwrap_unchecked()
}
}
}
impl<T: PyObjectPayload> PyAtomicRef<T> {
/// # Safety
/// The caller is responsible to keep the returned PyRef alive
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, pyref: PyRef<T>) -> PyRef<T> {
let py = PyRef::leak(pyref) as *const Py<T> as *mut _;
let old = Radium::swap(&self.inner, py, Ordering::AcqRel);
PyRef::from_raw(old.cast())
}
pub fn swap_to_temporary_refs(&self, pyref: PyRef<T>, vm: &VirtualMachine) {
let old = unsafe { self.swap(pyref) };
if let Some(frame) = vm.current_frame() {
frame.temporary_refs.lock().push(old.into());
}
}
}
impl<T: PyObjectPayload> From<Option<PyRef<T>>> for PyAtomicRef<Option<T>> {
fn from(opt_ref: Option<PyRef<T>>) -> Self {
let val = opt_ref
.map(|x| PyRef::leak(x) as *const Py<T> as *mut _)
.unwrap_or(null_mut());
Self {
inner: Radium::new(val),
_phantom: Default::default(),
}
}
}
impl<T: PyObjectPayload> PyAtomicRef<Option<T>> {
pub fn deref(&self) -> Option<&Py<T>> {
unsafe { self.inner.load(Ordering::Relaxed).cast::<Py<T>>().as_ref() }
}
pub fn to_owned(&self) -> Option<PyRef<T>> {
self.deref().map(|x| x.to_owned())
}
/// # Safety
/// The caller is responsible to keep the returned PyRef alive
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, opt_ref: Option<PyRef<T>>) -> Option<PyRef<T>> {
let val = opt_ref
.map(|x| PyRef::leak(x) as *const Py<T> as *mut _)
.unwrap_or(null_mut());
let old = Radium::swap(&self.inner, val, Ordering::AcqRel);
unsafe { old.cast::<Py<T>>().as_ref().map(|x| PyRef::from_raw(x)) }
}
pub fn swap_to_temporary_refs(&self, opt_ref: Option<PyRef<T>>, vm: &VirtualMachine) {
let Some(old) = (unsafe { self.swap(opt_ref) }) else {
return;
};
if let Some(frame) = vm.current_frame() {
frame.temporary_refs.lock().push(old.into());
}
}
}
impl From<PyObjectRef> for PyAtomicRef<PyObject> {
fn from(obj: PyObjectRef) -> Self {
let obj = obj.into_raw();
Self {
inner: Radium::new(obj as *mut _),
_phantom: Default::default(),
}
}
}
impl Deref for PyAtomicRef<PyObject> {
type Target = PyObject;
fn deref(&self) -> &Self::Target {
unsafe {
self.inner
.load(Ordering::Relaxed)
.cast::<PyObject>()
.as_ref()
.unwrap_unchecked()
}
}
}
impl PyAtomicRef<PyObject> {
/// # Safety
/// The caller is responsible to keep the returned PyRef alive
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, obj: PyObjectRef) -> PyObjectRef {
let obj = obj.into_raw();
let old = Radium::swap(&self.inner, obj as *mut _, Ordering::AcqRel);
PyObjectRef::from_raw(old as _)
}
pub fn swap_to_temporary_refs(&self, obj: PyObjectRef, vm: &VirtualMachine) {
let old = unsafe { self.swap(obj) };
if let Some(frame) = vm.current_frame() {
frame.temporary_refs.lock().push(old);
}
}
}
impl From<Option<PyObjectRef>> for PyAtomicRef<Option<PyObject>> {
fn from(obj: Option<PyObjectRef>) -> Self {
let val = obj.map(|x| x.into_raw() as *mut _).unwrap_or(null_mut());
Self {
inner: Radium::new(val),
_phantom: Default::default(),
}
}
}
impl PyAtomicRef<Option<PyObject>> {
pub fn deref(&self) -> Option<&PyObject> {
unsafe {
self.inner
.load(Ordering::Relaxed)
.cast::<PyObject>()
.as_ref()
}
}
pub fn to_owned(&self) -> Option<PyObjectRef> {
self.deref().map(|x| x.to_owned())
}
/// # Safety
/// The caller is responsible to keep the returned PyRef alive
/// until no more reference can be used via PyAtomicRef::deref()
#[must_use]
pub unsafe fn swap(&self, obj: Option<PyObjectRef>) -> Option<PyObjectRef> {
let val = obj.map(|x| x.into_raw() as *mut _).unwrap_or(null_mut());
let old = Radium::swap(&self.inner, val, Ordering::AcqRel);
old.cast::<PyObject>()
.as_ref()
.map(|x| PyObjectRef::from_raw(x))
}
pub fn swap_to_temporary_refs(&self, obj: Option<PyObjectRef>, vm: &VirtualMachine) {
let Some(old) = (unsafe { self.swap(obj) }) else {
return;
};
if let Some(frame) = vm.current_frame() {
frame.temporary_refs.lock().push(old);
}
}
}
pub trait AsObject
where
Self: Borrow<PyObject>,
{
#[inline(always)]
fn as_object(&self) -> &PyObject {
self.borrow()
}
#[inline(always)]
fn get_id(&self) -> usize {
self.as_object().unique_id()
}
#[inline(always)]
fn is<T>(&self, other: &T) -> bool
where
T: AsObject,
{
self.get_id() == other.get_id()
}
#[inline(always)]
fn class(&self) -> &Py<PyType> {
self.as_object().class()
}
fn get_class_attr(&self, attr_name: &'static PyStrInterned) -> Option<PyObjectRef> {
self.class().get_attr(attr_name)
}
/// Determines if `obj` actually an instance of `cls`, this doesn't call __instancecheck__, so only
/// use this if `cls` is known to have not overridden the base __instancecheck__ magic method.
#[inline]
fn fast_isinstance(&self, cls: &Py<PyType>) -> bool {
self.class().fast_issubclass(cls)
}
}
impl<T> AsObject for T where T: Borrow<PyObject> {}
impl PyObject {
#[inline(always)]
fn unique_id(&self) -> usize {
self as *const PyObject as usize
}
}
// impl<T: ?Sized> Borrow<PyObject> for PyRc<T> {
// #[inline(always)]
// fn borrow(&self) -> &PyObject {
// unsafe { &*(&**self as *const T as *const PyObject) }
// }
// }
/// A borrow of a reference to a Python object. This avoids having clone the `PyRef<T>`/
/// `PyObjectRef`, which isn't that cheap as that increments the atomic reference counter.
pub struct PyLease<'a, T: PyObjectPayload> {
inner: PyRwLockReadGuard<'a, PyRef<T>>,
}
impl<'a, T: PyObjectPayload + PyPayload> PyLease<'a, T> {
#[inline(always)]
pub fn into_owned(self) -> PyRef<T> {
self.inner.clone()
}
}
impl<'a, T: PyObjectPayload + PyPayload> Borrow<PyObject> for PyLease<'a, T> {
#[inline(always)]
fn borrow(&self) -> &PyObject {
self.inner.as_ref()
}
}
impl<'a, T: PyObjectPayload + PyPayload> Deref for PyLease<'a, T> {
type Target = PyRef<T>;
#[inline(always)]
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a, T> fmt::Display for PyLease<'a, T>
where
T: PyPayload + fmt::Display,
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
impl<T: PyObjectPayload> ToPyObject for PyRef<T> {
#[inline(always)]
fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
self.into()
}
}
impl ToPyObject for PyObjectRef {
#[inline(always)]
fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
self
}
}
impl ToPyObject for &PyObject {
#[inline(always)]
fn to_pyobject(self, _vm: &VirtualMachine) -> PyObjectRef {
self.to_owned()
}
}
// Allows a built-in function to return any built-in object payload without
// explicitly implementing `ToPyObject`.
impl<T> ToPyObject for T
where
T: PyPayload + Sized,
{
#[inline(always)]
fn to_pyobject(self, vm: &VirtualMachine) -> PyObjectRef {
PyPayload::into_pyobject(self, vm)
}
}
impl<T> ToPyResult for T
where
T: ToPyObject,
{
#[inline(always)]
fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
Ok(self.to_pyobject(vm))
}
}
impl<T, E> ToPyResult for Result<T, E>
where
T: ToPyObject,
E: IntoPyException,
{
#[inline(always)]
fn to_pyresult(self, vm: &VirtualMachine) -> PyResult {
self.map(|res| T::to_pyobject(res, vm))
.map_err(|e| E::into_pyexception(e, vm))
}
}
impl IntoPyException for PyBaseExceptionRef {
#[inline(always)]
fn into_pyexception(self, _vm: &VirtualMachine) -> PyBaseExceptionRef {
self
}
}
|
use crate::{
bodies::AxisAlignedBoundingBox, systems, Acceleration, BodyType, Drag, EntityCollision, Forces,
Gravity, Mass, PhysicsState, TileCollision, Velocity, TileCollisionAxis
};
use game_core::{combinators::if_all, modes::ModeExt, GameStage, GlobalMode, ModeEvent};
use game_lib::bevy::{ecs as bevy_ecs, prelude::*};
use game_tiles::TileSystem;
#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, SystemLabel)]
pub struct PhysicsPlugin;
impl Plugin for PhysicsPlugin {
fn build(&self, app: &mut AppBuilder) {
app.register_type::<Mass>()
.register_type::<Velocity>()
.register_type::<Acceleration>()
.register_type::<Forces>()
.register_type::<Gravity>()
.register_type::<Drag>()
.register_type::<BodyType>()
.register_type::<AxisAlignedBoundingBox>()
.register_type::<PhysicsState>()
.register_type::<EntityCollision>()
.register_type::<TileCollisionAxis>()
.register_type::<TileCollision>()
.add_event::<EntityCollision>()
.add_event::<TileCollision>()
.add_system_set_to_stage(
GameStage::GamePreUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.with_run_criteria(GlobalMode::InGame.on(ModeEvent::Enter))
.with_system(systems::setup.system()),
)
.add_system_set_to_stage(
GameStage::GamePostUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.with_run_criteria(GlobalMode::InGame.on(ModeEvent::Exit))
.with_system(systems::cleanup.system()),
)
.add_system_set_to_stage(
GameStage::GameUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.label(PhysicsSystem::UpdateState)
.with_run_criteria(GlobalMode::InGame.on(ModeEvent::Active))
.with_system(systems::update_physics_state.system()),
)
.add_system_set_to_stage(
GameStage::GameUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.label(PhysicsSystem::Prepare)
.after(PhysicsSystem::UpdateState)
.with_run_criteria(if_all(vec![
GlobalMode::InGame.on(ModeEvent::Active),
Box::new(systems::if_physics_lagged.system()),
]))
.with_system(
systems::add_kinematic_forces
.system()
.chain(systems::apply_forces.system())
.chain(systems::apply_acceleration.system()),
),
)
.add_system_set_to_stage(
GameStage::GameUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.label(PhysicsSystem::Run)
.after(PhysicsSystem::Prepare)
.with_run_criteria(if_all(vec![
GlobalMode::InGame.on(ModeEvent::Active),
Box::new(systems::while_physics_lagged.system()),
]))
.with_system(systems::step.system()),
)
.add_system_set_to_stage(
GameStage::GameUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.label(PhysicsSystem::Cleanup)
.before(TileSystem::DetectRedraw)
.after(PhysicsSystem::Run)
.with_run_criteria(GlobalMode::InGame.on(ModeEvent::Active))
.with_system(systems::update_transforms.system()),
)
.add_system_set_to_stage(
GameStage::GameUpdate,
SystemSet::new()
.label(PhysicsPlugin)
.label(PhysicsSystem::Cleanup)
.after(PhysicsSystem::Run)
.with_run_criteria(if_all(vec![
GlobalMode::InGame.on(ModeEvent::Active),
Box::new(systems::if_physics_lagged.system()),
]))
.with_system(systems::cleanup_kinematics.system())
.with_system(systems::reset_jumps.system()),
);
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash, SystemLabel)]
pub enum PhysicsSystem {
UpdateState,
Prepare,
Run,
Cleanup,
}
|
// Copyright (c) 2015-2016 Georg Brandl. Licensed under the Apache License,
// Version 2.0 <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>
// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at
// your option. This file may not be copied, modified, or distributed except
// according to those terms.
//! Serializer/Deserializer implementations for `value::Value`.
use std::vec;
use std::result::Result as StdResult;
use std::collections::{btree_map, BTreeMap};
use num_bigint::BigInt;
use num_traits::ToPrimitive;
use serde::{ser, de};
use serde::ser::Serialize;
use value::{Value, HashableValue};
use error::{Error, ErrorCode, Result};
impl de::Deserialize for Value {
#[inline]
fn deserialize<D>(deser: &mut D) -> StdResult<Value, D::Error> where D: de::Deserializer {
struct ValueVisitor;
impl de::Visitor for ValueVisitor {
type Value = Value;
#[inline]
fn visit_bool<E>(&mut self, value: bool) -> StdResult<Value, E> {
Ok(Value::Bool(value))
}
#[inline]
fn visit_i64<E>(&mut self, value: i64) -> StdResult<Value, E> {
Ok(Value::I64(value))
}
#[inline]
fn visit_u64<E>(&mut self, value: u64) -> StdResult<Value, E> {
if value < 0x8000_0000_0000_0000 {
Ok(Value::I64(value as i64))
} else {
Ok(Value::Int(BigInt::from(value)))
}
}
#[inline]
fn visit_f64<E>(&mut self, value: f64) -> StdResult<Value, E> {
Ok(Value::F64(value))
}
#[inline]
fn visit_str<E: de::Error>(&mut self, value: &str) -> StdResult<Value, E> {
self.visit_string(String::from(value))
}
#[inline]
fn visit_string<E>(&mut self, value: String) -> StdResult<Value, E> {
Ok(Value::String(value))
}
#[inline]
fn visit_bytes<E: de::Error>(&mut self, value: &[u8]) -> StdResult<Value, E> {
self.visit_byte_buf(value.to_vec())
}
#[inline]
fn visit_byte_buf<E: de::Error>(&mut self, value: Vec<u8>) -> StdResult<Value, E> {
Ok(Value::Bytes(value))
}
#[inline]
fn visit_none<E>(&mut self) -> StdResult<Value, E> {
Ok(Value::None)
}
#[inline]
fn visit_some<D>(&mut self, deser: &mut D)
-> StdResult<Value, D::Error> where D: de::Deserializer {
de::Deserialize::deserialize(deser)
}
#[inline]
fn visit_unit<E>(&mut self) -> StdResult<Value, E> {
Ok(Value::None)
}
#[inline]
fn visit_seq<V>(&mut self, visitor: V)
-> StdResult<Value, V::Error> where V: de::SeqVisitor {
let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
Ok(Value::List(values))
}
#[inline]
fn visit_map<V>(&mut self, visitor: V)
-> StdResult<Value, V::Error> where V: de::MapVisitor {
let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
Ok(Value::Dict(values))
}
}
deser.deserialize(ValueVisitor)
}
}
impl de::Deserialize for HashableValue {
#[inline]
fn deserialize<D>(deser: &mut D) -> StdResult<HashableValue, D::Error> where D: de::Deserializer {
struct ValueVisitor;
impl de::Visitor for ValueVisitor {
type Value = HashableValue;
#[inline]
fn visit_bool<E>(&mut self, value: bool) -> StdResult<HashableValue, E> {
Ok(HashableValue::Bool(value))
}
#[inline]
fn visit_i64<E>(&mut self, value: i64) -> StdResult<HashableValue, E> {
Ok(HashableValue::I64(value))
}
#[inline]
fn visit_u64<E>(&mut self, value: u64) -> StdResult<HashableValue, E> {
if value < 0x8000_0000_0000_0000 {
Ok(HashableValue::I64(value as i64))
} else {
Ok(HashableValue::Int(BigInt::from(value)))
}
}
#[inline]
fn visit_f64<E>(&mut self, value: f64) -> StdResult<HashableValue, E> {
Ok(HashableValue::F64(value))
}
#[inline]
fn visit_str<E: de::Error>(&mut self, value: &str) -> StdResult<HashableValue, E> {
self.visit_string(String::from(value))
}
#[inline]
fn visit_string<E>(&mut self, value: String) -> StdResult<HashableValue, E> {
Ok(HashableValue::String(value))
}
#[inline]
fn visit_none<E>(&mut self) -> StdResult<HashableValue, E> {
Ok(HashableValue::None)
}
#[inline]
fn visit_some<D>(&mut self, deser: &mut D)
-> StdResult<HashableValue, D::Error> where D: de::Deserializer {
de::Deserialize::deserialize(deser)
}
#[inline]
fn visit_unit<E>(&mut self) -> StdResult<HashableValue, E> {
Ok(HashableValue::None)
}
#[inline]
fn visit_seq<V>(&mut self, visitor: V)
-> StdResult<HashableValue, V::Error> where V: de::SeqVisitor {
let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
Ok(HashableValue::Tuple(values))
}
}
deser.deserialize(ValueVisitor)
}
}
/// Deserializes a decoded value into any serde supported value.
pub struct Deserializer {
value: Option<Value>,
}
impl Deserializer {
/// Creates a new deserializer instance for deserializing the specified JSON value.
pub fn new(value: Value) -> Deserializer {
Deserializer {
value: Some(value),
}
}
}
impl de::Deserializer for Deserializer {
type Error = Error;
fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value> where V: de::Visitor {
let value = match self.value.take() {
Some(value) => value,
None => { return Err(de::Error::end_of_stream()); }
};
match value {
Value::None => visitor.visit_unit(),
Value::Bool(v) => visitor.visit_bool(v),
Value::I64(v) => visitor.visit_i64(v),
Value::Int(v) => {
if let Some(i) = v.to_i64() {
visitor.visit_i64(i)
} else {
return Err(de::Error::invalid_value("integer too large"));
}
},
Value::F64(v) => visitor.visit_f64(v),
Value::Bytes(v) => visitor.visit_byte_buf(v),
Value::String(v) => visitor.visit_string(v),
Value::List(v) => {
let len = v.len();
visitor.visit_seq(SeqDeserializer {
de: self,
iter: v.into_iter(),
len: len,
})
},
Value::Tuple(v) => {
visitor.visit_seq(SeqDeserializer {
de: self,
len: v.len(),
iter: v.into_iter(),
})
}
Value::Set(v) | Value::FrozenSet(v) => {
let v: Vec<_> = v.into_iter().map(HashableValue::into_value).collect();
visitor.visit_seq(SeqDeserializer {
de: self,
len: v.len(),
iter: v.into_iter(),
})
},
Value::Dict(v) => {
let len = v.len();
visitor.visit_map(MapDeserializer {
de: self,
iter: v.into_iter(),
value: None,
len: len,
})
},
}
}
#[inline]
fn deserialize_bool<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_usize<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_u64(visitor)
}
#[inline]
fn deserialize_u8<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_u64(visitor)
}
#[inline]
fn deserialize_u16<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_u64(visitor)
}
#[inline]
fn deserialize_u32<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_u64(visitor)
}
#[inline]
fn deserialize_u64<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_isize<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_i64(visitor)
}
#[inline]
fn deserialize_i8<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_i64(visitor)
}
#[inline]
fn deserialize_i16<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_i64(visitor)
}
#[inline]
fn deserialize_i32<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_i64(visitor)
}
#[inline]
fn deserialize_i64<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_f32<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_f64(visitor)
}
#[inline]
fn deserialize_f64<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_char<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_f64(visitor)
}
#[inline]
fn deserialize_str<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_string<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_unit<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_option<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value> {
match self.value {
Some(Value::None) => visitor.visit_none(),
Some(_) => visitor.visit_some(self),
None => Err(de::Error::end_of_stream()),
}
}
#[inline]
fn deserialize_seq<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_seq_fixed_size<V: de::Visitor>(&mut self, _len: usize, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_bytes<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize_seq(visitor)
}
#[inline]
fn deserialize_map<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_unit_struct<V>(&mut self, _name: &str, visitor: V)
-> Result<V::Value> where V: de::Visitor {
self.deserialize_unit(visitor)
}
#[inline]
fn deserialize_newtype_struct<V>(&mut self, _name: &str, mut visitor: V)
-> Result<V::Value> where V: de::Visitor {
visitor.visit_newtype_struct(self)
}
#[inline]
fn deserialize_tuple_struct<V: de::Visitor>(&mut self, _name: &'static str,
_len: usize, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_struct<V: de::Visitor>(&mut self, _name: &'static str,
_fields: &'static [&'static str], visitor: V) -> Result<V::Value> {
self.deserialize_map(visitor)
}
#[inline]
fn deserialize_struct_field<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
#[inline]
fn deserialize_tuple<V: de::Visitor>(&mut self, _len: usize, visitor: V) -> Result<V::Value> {
self.deserialize_seq(visitor)
}
#[inline]
fn deserialize_enum<V>(&mut self, _name: &str, _variants: &'static [&'static str],
mut visitor: V) -> Result<V::Value> where V: de::EnumVisitor {
visitor.visit(self)
}
#[inline]
fn deserialize_ignored_any<V: de::Visitor>(&mut self, visitor: V) -> Result<V::Value> {
self.deserialize(visitor)
}
}
impl de::VariantVisitor for Deserializer {
type Error = Error;
fn visit_variant<V>(&mut self) -> Result<V> where V: de::Deserialize {
match self.value.take() {
Some(Value::Tuple(mut v)) => {
if v.len() == 2 {
let args = v.pop();
self.value = v.pop();
let res = de::Deserialize::deserialize(self);
self.value = args;
res
} else {
self.value = v.pop();
de::Deserialize::deserialize(self)
}
}
_ => Err(Error::Syntax(ErrorCode::Custom("enums must be tuples".into())))
}
}
fn visit_unit(&mut self) -> Result<()> {
Ok(())
}
fn visit_newtype<T>(&mut self) -> Result<T> where T: de::Deserialize {
de::Deserialize::deserialize(self)
}
fn visit_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value> where V: de::Visitor {
de::Deserializer::deserialize(self, visitor)
}
fn visit_struct<V>(&mut self, _fields: &'static [&'static str], visitor: V)
-> Result<V::Value> where V: de::Visitor {
de::Deserializer::deserialize(self, visitor)
}
}
struct SeqDeserializer<'a> {
de: &'a mut Deserializer,
iter: vec::IntoIter<Value>,
len: usize,
}
impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
type Error = Error;
fn visit<T>(&mut self) -> Result<Option<T>> where T: de::Deserialize {
match self.iter.next() {
Some(value) => {
self.len -= 1;
self.de.value = Some(value);
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
None => Ok(None),
}
}
fn end(&mut self) -> Result<()> {
if self.len == 0 {
Ok(())
} else {
Err(de::Error::invalid_length(self.len))
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
}
}
struct MapDeserializer<'a> {
de: &'a mut Deserializer,
iter: btree_map::IntoIter<HashableValue, Value>,
value: Option<Value>,
len: usize,
}
impl<'a> de::MapVisitor for MapDeserializer<'a> {
type Error = Error;
fn visit_key<T>(&mut self) -> Result<Option<T>> where T: de::Deserialize {
match self.iter.next() {
Some((key, value)) => {
self.len -= 1;
self.value = Some(value);
self.de.value = Some(key.into_value());
Ok(Some(try!(de::Deserialize::deserialize(self.de))))
}
None => Ok(None),
}
}
fn visit_value<T>(&mut self) -> Result<T> where T: de::Deserialize {
let value = self.value.take().unwrap();
self.de.value = Some(value);
Ok(try!(de::Deserialize::deserialize(self.de)))
}
fn end(&mut self) -> Result<()> {
if self.len == 0 {
Ok(())
} else {
Err(de::Error::invalid_length(self.len))
}
}
fn missing_field<V>(&mut self, field: &'static str) -> Result<V> where V: de::Deserialize {
Err(de::Error::missing_field(field))
}
fn size_hint(&self) -> (usize, Option<usize>) {
(self.len, Some(self.len))
}
}
/// Create a `serde::Serializer` that serializes a `Serialize`e into a `Value`.
pub struct Serializer {
values: Vec<Value>,
}
impl Serializer {
/// Construct a new `Serializer`.
pub fn new() -> Serializer {
Serializer {
values: Vec::with_capacity(16),
}
}
/// Unwrap the `Serializer` and return the `Value`.
pub fn finish(mut self) -> Result<Value> {
self.values.pop().ok_or_else(|| ser::Error::custom("expected a value"))
}
}
impl Default for Serializer {
fn default() -> Self {
Self::new()
}
}
impl ser::Serializer for Serializer {
type Error = Error;
type SeqState = Serializer;
type TupleState = Self::SeqState;
type MapState = (BTreeMap<HashableValue, Value>, Serializer);
type StructState = Self::MapState;
type TupleStructState = Self::TupleState;
type StructVariantState = Self::MapState;
type TupleVariantState = Self::TupleState;
#[inline]
fn serialize_bool(&mut self, value: bool) -> Result<()> {
self.values.push(Value::Bool(value));
Ok(())
}
#[inline]
fn serialize_isize(&mut self, v: isize) -> Result<()> {
self.serialize_i64(v as i64)
}
#[inline]
fn serialize_i8(&mut self, v: i8) -> Result<()> {
self.serialize_i64(v as i64)
}
#[inline]
fn serialize_i16(&mut self, v: i16) -> Result<()> {
self.serialize_i64(v as i64)
}
#[inline]
fn serialize_i32(&mut self, v: i32) -> Result<()> {
self.serialize_i64(v as i64)
}
#[inline]
fn serialize_i64(&mut self, value: i64) -> Result<()> {
self.values.push(Value::I64(value));
Ok(())
}
#[inline]
fn serialize_usize(&mut self, v: usize) -> Result<()> {
self.serialize_u64(v as u64)
}
#[inline]
fn serialize_u8(&mut self, v: u8) -> Result<()> {
self.serialize_u64(v as u64)
}
#[inline]
fn serialize_u16(&mut self, v: u16) -> Result<()> {
self.serialize_u64(v as u64)
}
#[inline]
fn serialize_u32(&mut self, v: u32) -> Result<()> {
self.serialize_u64(v as u64)
}
#[inline]
fn serialize_u64(&mut self, value: u64) -> Result<()> {
if value < 0x8000_0000_0000_0000 {
self.values.push(Value::I64(value as i64));
} else {
self.values.push(Value::Int(BigInt::from(value)));
}
Ok(())
}
#[inline]
fn serialize_f32(&mut self, value: f32) -> Result<()> {
self.serialize_f64(value as f64)
}
#[inline]
fn serialize_f64(&mut self, value: f64) -> Result<()> {
self.values.push(Value::F64(value));
Ok(())
}
#[inline]
fn serialize_char(&mut self, value: char) -> Result<()> {
let mut s = String::new();
s.push(value);
self.values.push(Value::String(s));
Ok(())
}
#[inline]
fn serialize_str(&mut self, value: &str) -> Result<()> {
self.values.push(Value::String(String::from(value)));
Ok(())
}
#[inline]
fn serialize_bytes(&mut self, value: &[u8]) -> Result<()> {
self.values.push(Value::Bytes(value.to_vec()));
Ok(())
}
#[inline]
fn serialize_none(&mut self) -> Result<()> {
self.serialize_unit()
}
#[inline]
fn serialize_some<V>(&mut self, value: V) -> Result<()>
where V: Serialize,
{
value.serialize(self)
}
#[inline]
fn serialize_unit(&mut self) -> Result<()> {
self.values.push(Value::None);
Ok(())
}
#[inline]
fn serialize_unit_variant(&mut self, _name: &str, _variant_index: usize, variant: &str)
-> Result<()> {
self.values.push(Value::Tuple(vec![Value::String(variant.into())]));
Ok(())
}
#[inline]
fn serialize_newtype_variant<T>(&mut self, _name: &str, _variant_index: usize, variant: &str,
value: T) -> Result<()> where T: Serialize {
self.values.push(Value::Tuple(vec![Value::String(variant.into()),
try!(to_value(&value))]));
Ok(())
}
#[inline]
fn serialize_tuple_variant(&mut self, _name: &str, _variant_index: usize, variant: &str,
len: usize) -> Result<Serializer> {
try!(self.serialize_str(variant));
self.serialize_seq_fixed_size(len)
}
#[inline]
fn serialize_tuple_variant_elt<T: Serialize>(&mut self, state: &mut Serializer,
value: T) -> Result<()> {
self.serialize_seq_elt(state, value)
}
#[inline]
fn serialize_tuple_variant_end(&mut self, state: Serializer) -> Result<()> {
try!(self.serialize_seq_end(state));
let seq = self.values.pop().unwrap();
let var = self.values.pop().unwrap();
self.values.push(Value::Tuple(vec![var, seq]));
Ok(())
}
#[inline]
fn serialize_struct_variant(&mut self, _name: &str, _variant_index: usize, variant: &str,
len: usize) -> Result<Self::MapState> {
try!(self.serialize_str(variant));
self.serialize_map(Some(len))
}
#[inline]
fn serialize_struct_variant_elt<T: Serialize>(&mut self, state: &mut Self::MapState,
key: &'static str, value: T) -> Result<()> {
try!(self.serialize_map_key(state, key));
self.serialize_map_value(state, value)
}
#[inline]
fn serialize_struct_variant_end(&mut self, state: Self::MapState) -> Result<()> {
try!(self.serialize_map_end(state));
let map = self.values.pop().unwrap();
let var = self.values.pop().unwrap();
self.values.push(Value::Tuple(vec![var, map]));
Ok(())
}
#[inline]
fn serialize_struct(&mut self, _name: &'static str, len: usize) -> Result<Self::MapState> {
self.serialize_map(Some(len))
}
#[inline]
fn serialize_struct_elt<T: Serialize>(&mut self, state: &mut Self::MapState,
key: &'static str, value: T) -> Result<()> {
try!(self.serialize_map_key(state, key));
self.serialize_map_value(state, value)
}
#[inline]
fn serialize_struct_end(&mut self, state: Self::MapState) -> Result<()> {
self.serialize_map_end(state)
}
#[inline]
fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<()> {
self.values.push(Value::Tuple(vec![]));
Ok(())
}
#[inline]
fn serialize_newtype_struct<T>(&mut self, _name: &'static str, value: T)
-> Result<()> where T: Serialize {
value.serialize(self)
}
#[inline]
fn serialize_tuple_struct(&mut self, _name: &'static str, len: usize) -> Result<Serializer> {
self.serialize_tuple(len)
}
#[inline]
fn serialize_tuple_struct_elt<T: Serialize>(&mut self, state: &mut Serializer, value: T) -> Result<()> {
self.serialize_tuple_elt(state, value)
}
#[inline]
fn serialize_tuple_struct_end(&mut self, state: Serializer) -> Result<()> {
self.serialize_tuple_end(state)
}
#[inline]
fn serialize_tuple(&mut self, _len: usize) -> Result<Serializer> {
Ok(Serializer::new())
}
#[inline]
fn serialize_tuple_elt<T: Serialize>(&mut self, state: &mut Serializer, value: T) -> Result<()> {
value.serialize(state)
}
#[inline]
fn serialize_tuple_end(&mut self, state: Serializer) -> Result<()> {
self.values.push(Value::Tuple(state.values));
Ok(())
}
#[inline]
fn serialize_seq_fixed_size(&mut self, len: usize) -> Result<Serializer> {
self.serialize_seq(Some(len))
}
#[inline]
fn serialize_seq(&mut self, _len: Option<usize>) -> Result<Serializer> {
Ok(Serializer::new())
}
#[inline]
fn serialize_seq_elt<T: Serialize>(&mut self, state: &mut Serializer, value: T) -> Result<()> {
value.serialize(state)
}
#[inline]
fn serialize_seq_end(&mut self, state: Serializer) -> Result<()> {
self.values.push(Value::List(state.values));
Ok(())
}
#[inline]
fn serialize_map(&mut self, _len: Option<usize>) -> Result<Self::MapState> {
Ok((BTreeMap::new(), Serializer::new()))
}
#[inline]
fn serialize_map_key<T: Serialize>(&mut self,
state: &mut Self::MapState,
key: T) -> Result<()> {
key.serialize(&mut state.1)
}
#[inline]
fn serialize_map_value<T: Serialize>(&mut self,
state: &mut Self::MapState,
value: T) -> Result<()> {
try!(value.serialize(&mut state.1));
let value = state.1.values.pop().unwrap();
let key = try!(state.1.values.pop().unwrap().into_hashable());
state.0.insert(key, value);
Ok(())
}
#[inline]
fn serialize_map_end(&mut self, state: Self::MapState) -> Result<()> {
self.values.push(Value::Dict(state.0));
Ok(())
}
}
/// Serialize any serde serializable object into a `value::Value`.
pub fn to_value<T: Serialize + ?Sized>(value: &T) -> Result<Value> {
let mut ser = Serializer::new();
value.serialize(&mut ser).ok().unwrap();
ser.finish()
}
/// Deserialize a `value::Value` from any serde deserializable object.
pub fn from_value<T: de::Deserialize>(value: Value) -> Result<T> {
let mut de = Deserializer::new(value);
de::Deserialize::deserialize(&mut de)
}
|
// TODO
// - MAKE AN ALERT FOR JEFFERY BECAUSE YOU LOVE HIM
// - BUG - when bomb is on far right side, the space directly to the left often doesn't get
// calculated properly
// - add smiley
// - requires facial animations while clicking on flagged
// - add numbers
// - need to create time and mines variables that are shared
// - these to have to have numeric representations in the code
// like how the open spaces have representations in the code.
// OR not and just store it as a number
// - TODO how tf to timers work in this language, std::Duration?
// - levels of difficulty
// - look into the source code to see what the difficulties are
// search for "Expert"
// - remove now-redudant parts of setting size passing
use piston::window::WindowSettings;
use piston::input::{RenderEvent};
use piston::event_loop::{Events, EventSettings};
use glutin_window::GlutinWindow;
use opengl_graphics::{OpenGL, GlGraphics};
mod minesweeper;
mod minesweeper_controller;
mod minesweeper_view;
pub use crate::minesweeper::{MineSweeper, ROWS, COLS};
pub use crate::minesweeper_controller::MineSweeperController;
pub use crate::minesweeper_view::{MineSweeperView, MineSweeperViewSettings};
fn main() {
// initialize custom classes to handle events and the like
// model
let ms = MineSweeper::new();
// controller
let mut ms_c = MineSweeperController::new(ms);
// view
let settings = MineSweeperViewSettings::new(ROWS, COLS, 2.5);
let width: f64 = settings.cols as f64 * settings.square_side + 2.0 * settings.border_long;
let height: f64 = settings.rows as f64 * settings.square_side + 3.0 * settings.border_long + settings.smiley_side;
// create window
let opengl = OpenGL::V3_2;
let window_settings = WindowSettings::new("Mine Sweeper", [width, height])
.graphics_api(opengl)
.resizable(false)
.exit_on_esc(true);
let mut window: GlutinWindow = window_settings.build()
.expect("Could not create window");
let mut event_settings = EventSettings::new();
event_settings.lazy = true;
let mut events = Events::new(event_settings);
let mut gl = GlGraphics::new(opengl);
let ms_v = MineSweeperView::new(settings.clone());
// event loop
while let Some(e) = events.next(&mut window) {
// handle input event
ms_c.event(settings.clone(), &e);
// handle rendering
if let Some(r) = e.render_args() {
gl.draw(r.viewport(), |c, g| {
use graphics::clear;
// clear screen and call draw function
clear([0.8, 0.8, 0.8, 1.0], g);
ms_v.draw(&ms_c, &c, g);
});
}
}
}
|
use gfx_maths::*;
/// Renders a brdf example
use std::{path::Path, rc::Rc};
use vulkan_engine::{
core::engine::Engine,
scene::{
component::{
camera_component::CameraComponent, debug_movement_component::DebugMovementComponent,
light_component::LightComponent, renderer::RendererComponent,
rotation_component::RotationComponent,
},
light::{DirectionalLight, PointLight},
material::MaterialPipeline,
model::Model,
transform::Transform,
},
};
use vulkan_engine::{
scene::model::mesh::Mesh,
vulkan::{lighting_pipeline::LightingPipeline, pp_effect::PPEffect},
};
fn main() {
vulkan_engine::run_engine(1920, 1080, "BRDF Example", setup);
}
fn setup(engine: &mut Engine) {
let scene = &mut engine.scene;
// pipeline setup
let pp_tonemap = PPEffect::new(
"tone_map",
engine.vulkan_manager.pipe_layout_pp,
engine.vulkan_manager.renderpass_pp,
engine.vulkan_manager.device.clone(),
)
.unwrap();
engine.vulkan_manager.register_pp_effect(pp_tonemap);
let brdf_lighting = LightingPipeline::new(
Some("deferred_point_brdf"),
Some("deferred_directional_brdf"),
None,
engine.vulkan_manager.pipeline_layout_resolve_pass,
engine.vulkan_manager.renderpass,
engine.vulkan_manager.device.clone(),
1,
)
.unwrap();
engine
.vulkan_manager
.register_lighting_pipeline(brdf_lighting.clone());
let brdf_pipeline = MaterialPipeline::new(
engine.vulkan_manager.device.clone(),
(*engine.vulkan_manager.allocator).clone(),
"material_solid_color",
engine.vulkan_manager.desc_layout_frame_data,
engine.vulkan_manager.renderpass,
brdf_lighting.as_ref(),
)
.unwrap();
let mesh_data_sphere_smooth =
ve_format::mesh::MeshData::from_file(Path::new("./assets/models/sphere_smooth.vem"))
.expect("Model sphere_smooth.vem not found!");
let mesh_sphere_smooth = Mesh::bake(
mesh_data_sphere_smooth,
(*engine.vulkan_manager.allocator).clone(),
&mut engine.vulkan_manager.uploader,
)
.unwrap();
let main_cam = scene.new_entity_with_transform(
"Main Camera".to_owned(),
Transform {
position: Vec3::new(0.0, 0.0, -5.0),
rotation: Quaternion::identity(),
scale: Vec3::one(),
},
);
main_cam.new_component::<CameraComponent>();
main_cam.new_component::<DebugMovementComponent>();
// setup models
for x in 0..11 {
for y in 0..11 {
let material = brdf_pipeline.create_material().unwrap();
material
.set_vec4("albedo", Vec4::new(0.5, 0.5, 0.5, 0.0))
.unwrap();
material.set_float("metallic", (x as f32) * 0.1).unwrap();
material.set_float("roughness", (y as f32) * 0.1).unwrap();
let model = Model {
material,
mesh: mesh_sphere_smooth.clone(),
};
// println!("start");
let entity = scene.new_entity_with_transform(
"BRDF Sphere".to_string(),
Transform {
position: Vec3::new(x as f32 - 5.0, y as f32 - 5.0, 10.0),
rotation: Quaternion::new(0.0, 0.0, 0.0, 1.0),
scale: Vec3::new(0.5, 0.5, 0.5),
},
);
let component = entity.new_component::<RendererComponent>();
*component.model.borrow_mut() = Some(Rc::new(model));
}
}
let sun = scene.new_entity_with_transform(
"Sun".to_string(),
Transform {
position: Vec3::zero(),
rotation: Quaternion::axis_angle(Vec3::new(1.0, 0.0, 0.0), -90.0f32.to_radians()),
scale: Vec3::one(),
},
);
sun.new_component::<LightComponent>().light.set(
DirectionalLight {
direction: Vec4::zero(),
illuminance: Vec4::new(239.0, 245.0, 218.0, 0.0) / 50.0,
}
.into(),
);
sun.new_component::<RotationComponent>();
scene
.new_entity_with_transform(
"PointLight White 1".to_string(),
Transform {
position: Vec3::new(0.1, -3.0, -3.0),
rotation: Quaternion::identity(),
scale: Vec3::one(),
},
)
.new_component::<LightComponent>()
.light
.set(
PointLight {
position: Vec4::zero(),
luminous_flux: Vec4::new(100.0, 100.0, 100.0, 0.0),
}
.into(),
);
scene
.new_entity_with_transform(
"PointLight White 2".to_string(),
Transform {
position: Vec3::new(0.1, -3.0, -3.0),
rotation: Quaternion::identity(),
scale: Vec3::one(),
},
)
.new_component::<LightComponent>()
.light
.set(
PointLight {
position: Vec4::zero(),
luminous_flux: Vec4::new(100.0, 100.0, 100.0, 0.0),
}
.into(),
);
scene
.new_entity_with_transform(
"PointLight Cyan 3".to_string(),
Transform {
position: Vec3::new(0.0, 0.0, 8.0),
rotation: Quaternion::identity(),
scale: Vec3::one(),
},
)
.new_component::<LightComponent>()
.light
.set(
PointLight {
position: Vec4::zero(),
luminous_flux: Vec4::new(0.0, 160.0, 145.0, 0.0) * 2.0,
}
.into(),
);
scene.load();
}
|
use std::io::{
Cursor,
Error as IOError,
ErrorKind,
};
use std::path::Path;
use std::sync::Arc;
use regex::Regex;
use sourcerenderer_core::Platform;
use sourcerenderer_vpk::{
Package,
PackageError,
};
use crate::asset::asset_manager::{
AssetContainer,
AssetFile,
AssetLoadPriority,
AssetLoaderResult,
};
use crate::asset::{
AssetLoader,
AssetLoaderProgress,
AssetManager,
};
pub(super) const CSGO_PRIMARY_PAK_NAME_PATTERN: &str = r"pak01_dir(\.vpk)*";
pub(super) const CSGO_PAK_NAME_PATTERN: &str = r"pak[0-9]*[0-9]_[0-9]+(\.vpk)*";
pub struct VPKContainer {
package: Package<AssetFile>,
}
pub fn new_vpk_container<P: Platform>(
asset_manager: &Arc<AssetManager<P>>,
asset_file: AssetFile,
) -> Result<Box<dyn AssetContainer>, PackageError> {
let path = asset_file.path.clone();
let asset_manager = Arc::downgrade(asset_manager);
Package::read(&path, asset_file, move |path| {
let mgr = asset_manager
.upgrade()
.ok_or_else(|| IOError::new(ErrorKind::Other, "Manager dropped"))?;
mgr.load_file(path)
.ok_or_else(|| IOError::new(ErrorKind::NotFound, "File not found"))
})
.map(|package| Box::new(VPKContainer { package }) as Box<dyn AssetContainer>)
}
impl AssetContainer for VPKContainer {
fn contains(&self, path: &str) -> bool {
self.package.find_entry(path).is_some()
}
fn load(&self, path: &str) -> Option<AssetFile> {
let entry = self.package.find_entry(path);
entry
.and_then(|entry| self.package.read_entry(entry, false).ok())
.map(|data| AssetFile {
path: path.to_string(),
data: Cursor::new(data),
})
}
}
pub struct VPKContainerLoader {
pak_name_regex: Regex,
}
impl VPKContainerLoader {
pub fn new() -> Self {
Self {
pak_name_regex: Regex::new(CSGO_PRIMARY_PAK_NAME_PATTERN).unwrap(),
}
}
}
impl<P: Platform> AssetLoader<P> for VPKContainerLoader {
fn matches(&self, file: &mut AssetFile) -> bool {
let file_name = Path::new(&file.path).file_stem();
file_name
.and_then(|file_name| file_name.to_str())
.map_or(false, |file_name| self.pak_name_regex.is_match(file_name))
}
fn load(
&self,
file: AssetFile,
manager: &Arc<AssetManager<P>>,
_priority: AssetLoadPriority,
progress: &Arc<AssetLoaderProgress>,
) -> Result<AssetLoaderResult, ()> {
let container = new_vpk_container::<P>(manager, file).unwrap();
manager.add_container_with_progress(container, Some(progress));
Ok(AssetLoaderResult::None)
}
}
|
// Copyright 2022 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use std::collections::HashMap;
use std::collections::HashSet;
use std::path::Path;
use std::sync::Arc;
use std::time::Instant;
use chrono::DateTime;
use chrono::Utc;
use common_base::runtime::execute_futures_in_parallel;
use common_catalog::table_context::TableContext;
use common_exception::ErrorCode;
use common_exception::Result;
use futures::stream::StreamExt;
use futures_util::TryStreamExt;
use opendal::EntryMode;
use opendal::Metakey;
use opendal::Operator;
use storages_common_cache::LoadParams;
use storages_common_table_meta::meta::Location;
use storages_common_table_meta::meta::SnapshotId;
use storages_common_table_meta::meta::TableSnapshot;
use storages_common_table_meta::meta::TableSnapshotLite;
use tracing::info;
use tracing::warn;
use tracing::Instrument;
use crate::io::MetaReaders;
use crate::io::SnapshotHistoryReader;
use crate::io::TableMetaLocationGenerator;
// Read snapshot related operations.
pub struct SnapshotsIO {
ctx: Arc<dyn TableContext>,
operator: Operator,
format_version: u64,
}
pub struct SnapshotLiteListExtended {
pub chained_snapshot_lites: Vec<TableSnapshotLite>,
pub segment_locations: HashMap<Location, HashSet<SnapshotId>>,
pub orphan_snapshot_lites: Vec<TableSnapshotLite>,
}
#[derive(Clone)]
pub enum ListSnapshotLiteOption {
// do not case about the segments
NeedNotSegments,
// need segment, and exclude the locations if Some(Hashset<Location>) is provided
NeedSegmentsWithExclusion(Option<Arc<HashSet<Location>>>),
}
struct SnapshotLiteExtended {
snapshot_lite: TableSnapshotLite,
segment_locations: HashMap<Location, HashSet<SnapshotId>>,
}
impl SnapshotsIO {
pub fn create(ctx: Arc<dyn TableContext>, operator: Operator, format_version: u64) -> Self {
Self {
ctx,
operator,
format_version,
}
}
async fn read_snapshot(
snapshot_location: String,
format_version: u64,
data_accessor: Operator,
) -> Result<Arc<TableSnapshot>> {
let reader = MetaReaders::table_snapshot_reader(data_accessor);
let load_params = LoadParams {
location: snapshot_location,
len_hint: None,
ver: format_version,
put_cache: true,
};
reader.read(&load_params).await
}
async fn read_snapshot_lite(
snapshot_location: String,
format_version: u64,
data_accessor: Operator,
min_snapshot_timestamp: Option<DateTime<Utc>>,
list_options: ListSnapshotLiteOption,
) -> Result<SnapshotLiteExtended> {
let reader = MetaReaders::table_snapshot_reader(data_accessor);
let load_params = LoadParams {
location: snapshot_location,
len_hint: None,
ver: format_version,
put_cache: false,
};
let snapshot = reader.read(&load_params).await?;
if snapshot.timestamp > min_snapshot_timestamp {
// filter out snapshots which have larger (artificial)timestamp , they are
// not members of precedents of the current snapshot, whose timestamp is
// min_snapshot_timestamp.
//
// NOTE: it is NOT the case that all those have lesser timestamp, are
// members of precedents of the current snapshot, though.
// Error is directly returned, since it can be ignored through flatten
// in read_snapshot_lites_ext.
return Err(ErrorCode::StorageOther(
"The timestamp of snapshot need less than the min_snapshot_timestamp",
));
}
let snapshot_id = snapshot.snapshot_id;
let mut segment_locations: HashMap<Location, HashSet<SnapshotId>> = HashMap::new();
if let ListSnapshotLiteOption::NeedSegmentsWithExclusion(filter) = list_options {
// collects segments, and the snapshots that reference them.
for segment_location in &snapshot.segments {
if let Some(excludes) = filter.as_ref() {
if excludes.contains(segment_location) {
continue;
}
}
segment_locations
.entry(segment_location.clone())
.and_modify(|v| {
v.insert(snapshot_id);
})
.or_insert_with(|| HashSet::from_iter(vec![snapshot_id]));
}
}
Ok(SnapshotLiteExtended {
snapshot_lite: TableSnapshotLite::from(snapshot.as_ref()),
segment_locations,
})
}
#[tracing::instrument(level = "debug", skip_all)]
async fn read_snapshot_lites(
&self,
snapshot_files: &[String],
min_snapshot_timestamp: Option<DateTime<Utc>>,
list_options: &ListSnapshotLiteOption,
) -> Result<Vec<Result<SnapshotLiteExtended>>> {
// combine all the tasks.
let mut iter = snapshot_files.iter();
let tasks = std::iter::from_fn(move || {
iter.next().map(|location| {
Self::read_snapshot_lite(
location.clone(),
self.format_version,
self.operator.clone(),
min_snapshot_timestamp,
list_options.clone(),
)
.instrument(tracing::debug_span!("read_snapshot"))
})
});
let threads_nums = self.ctx.get_settings().get_max_threads()? as usize;
let permit_nums = self.ctx.get_settings().get_max_storage_io_requests()? as usize;
execute_futures_in_parallel(
tasks,
threads_nums,
permit_nums,
"fuse-req-snapshots-worker".to_owned(),
)
.await
}
// Read all the table statistic files by the root file(exclude the root file).
// limit: read how many table statistic files
pub async fn read_table_statistic_files(
&self,
root_ts_file: &str,
limit: Option<usize>,
) -> Result<Vec<String>> {
// Get all file list.
if let Some(prefix) = Self::get_s3_prefix_from_file(root_ts_file) {
return self.list_files(&prefix, limit, Some(root_ts_file)).await;
}
Ok(vec![])
}
// read all the precedent snapshots of given `root_snapshot`
pub async fn read_chained_snapshot_lites(
&self,
location_generator: TableMetaLocationGenerator,
root_snapshot: String,
limit: Option<usize>,
) -> Result<Vec<TableSnapshotLite>> {
let table_snapshot_reader =
MetaReaders::table_snapshot_reader(self.ctx.get_data_operator()?.operator());
let lite_snapshot_stream = table_snapshot_reader
.snapshot_history(root_snapshot, self.format_version, location_generator)
.map_ok(|snapshot| TableSnapshotLite::from(snapshot.as_ref()));
if let Some(l) = limit {
lite_snapshot_stream.take(l).try_collect::<Vec<_>>().await
} else {
lite_snapshot_stream.try_collect::<Vec<_>>().await
}
}
// Read all the snapshots by the root file.
// limit: limits the number of snapshot files listed
// with_segment_locations: if true will get the segments of the snapshot
pub async fn read_snapshot_lites_ext<T>(
&self,
root_snapshot_file: String,
limit: Option<usize>,
list_options: &ListSnapshotLiteOption,
min_snapshot_timestamp: Option<DateTime<Utc>>,
status_callback: T,
) -> Result<SnapshotLiteListExtended>
where
T: Fn(String),
{
let ctx = self.ctx.clone();
let data_accessor = self.operator.clone();
// List all the snapshot file paths
// note that snapshot file paths of ongoing txs might be included
let mut snapshot_files = vec![];
let mut segment_location_with_index: HashMap<Location, HashSet<SnapshotId>> =
HashMap::new();
if let Some(prefix) = Self::get_s3_prefix_from_file(&root_snapshot_file) {
snapshot_files = self.list_files(&prefix, limit, None).await?;
}
// 1. Get all the snapshot by chunks.
let max_io_requests = ctx.get_settings().get_max_storage_io_requests()? as usize;
let mut snapshot_lites = Vec::with_capacity(snapshot_files.len());
let start = Instant::now();
let mut count = 0;
for chunk in snapshot_files.chunks(max_io_requests) {
let results = self
.read_snapshot_lites(chunk, min_snapshot_timestamp, list_options)
.await?;
for snapshot_lite_extend in results.into_iter().flatten() {
snapshot_lites.push(snapshot_lite_extend.snapshot_lite);
for (k, v) in snapshot_lite_extend.segment_locations.into_iter() {
segment_location_with_index
.entry(k)
.and_modify(|val| val.extend(v.iter()))
.or_insert(v);
}
}
// Refresh status.
{
count += chunk.len();
let status = format!(
"gc: read snapshot files:{}/{}, cost:{} sec",
count,
snapshot_files.len(),
start.elapsed().as_secs()
);
info!(status);
(status_callback)(status);
}
}
let root_snapshot = Self::read_snapshot(
root_snapshot_file.clone(),
self.format_version,
data_accessor.clone(),
)
.await?;
let (chained_snapshot_lites, orphan_snapshot_lites) =
Self::chain_snapshots(snapshot_lites, &root_snapshot);
Ok(SnapshotLiteListExtended {
chained_snapshot_lites,
segment_locations: segment_location_with_index,
orphan_snapshot_lites,
})
}
fn chain_snapshots(
snapshot_lites: Vec<TableSnapshotLite>,
root_snapshot: &TableSnapshot,
) -> (Vec<TableSnapshotLite>, Vec<TableSnapshotLite>) {
let mut snapshot_map = HashMap::new();
let mut chained_snapshot_lites = vec![];
for snapshot_lite in snapshot_lites.into_iter() {
snapshot_map.insert(snapshot_lite.snapshot_id, snapshot_lite);
}
let root_snapshot_lite = TableSnapshotLite::from(root_snapshot);
let mut prev_snapshot_id_tuple = root_snapshot_lite.prev_snapshot_id;
chained_snapshot_lites.push(root_snapshot_lite);
while let Some((prev_snapshot_id, _)) = prev_snapshot_id_tuple {
let prev_snapshot_lite = snapshot_map.remove(&prev_snapshot_id);
match prev_snapshot_lite {
None => {
break;
}
Some(prev_snapshot) => {
prev_snapshot_id_tuple = prev_snapshot.prev_snapshot_id;
chained_snapshot_lites.push(prev_snapshot);
}
}
}
// remove root from orphan list
snapshot_map.remove(&root_snapshot.snapshot_id);
(chained_snapshot_lites, snapshot_map.into_values().collect())
}
async fn list_files(
&self,
prefix: &str,
limit: Option<usize>,
exclude_file: Option<&str>,
) -> Result<Vec<String>> {
let op = self.operator.clone();
let mut file_list = vec![];
let mut ds = op.list(prefix).await?;
while let Some(de) = ds.try_next().await? {
let meta = op
.metadata(&de, Metakey::Mode | Metakey::LastModified)
.await?;
match meta.mode() {
EntryMode::FILE => match exclude_file {
Some(path) if de.path() == path => continue,
_ => {
let location = de.path().to_string();
let modified = meta.last_modified();
file_list.push((location, modified));
}
},
_ => {
warn!("found not snapshot file in {:}, found: {:?}", prefix, de);
continue;
}
}
}
// let mut vector: Vec<(i32, Option<i32>)> = vec![(1, Some(1)), (2, None), (3, Some(3)), (4, None)];
// vector.sort_by(|(_, k1), (_, k2)| k2.cmp(k1));
// Result:
// [(3, Some(3)), (1, Some(1)), (2, None),(4, None)]
file_list.sort_by(|(_, m1), (_, m2)| m2.cmp(m1));
Ok(match limit {
None => file_list.into_iter().map(|v| v.0).collect::<Vec<String>>(),
Some(v) => file_list
.into_iter()
.take(v)
.map(|v| v.0)
.collect::<Vec<String>>(),
})
}
// _ss/xx/yy.json -> _ss/xx/
fn get_s3_prefix_from_file(file_path: &str) -> Option<String> {
if let Some(path) = Path::new(&file_path).parent() {
let mut prefix = path.to_str().unwrap_or("").to_string();
if !prefix.contains('/') {
return None;
}
// Append '/' to the end if need.
if !prefix.ends_with('/') {
prefix += "/";
}
return Some(prefix);
}
None
}
}
|
#![allow(unused_variables, non_upper_case_globals, non_snake_case, unused_unsafe, non_camel_case_types, dead_code, clippy::all)]
pub const DEFAULT_WEIGHT: u32 = 1u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPIDSPRG(pub i32);
pub const DISPID_SRGId: DISPIDSPRG = DISPIDSPRG(1i32);
pub const DISPID_SRGRecoContext: DISPIDSPRG = DISPIDSPRG(2i32);
pub const DISPID_SRGState: DISPIDSPRG = DISPIDSPRG(3i32);
pub const DISPID_SRGRules: DISPIDSPRG = DISPIDSPRG(4i32);
pub const DISPID_SRGReset: DISPIDSPRG = DISPIDSPRG(5i32);
pub const DISPID_SRGCommit: DISPIDSPRG = DISPIDSPRG(6i32);
pub const DISPID_SRGCmdLoadFromFile: DISPIDSPRG = DISPIDSPRG(7i32);
pub const DISPID_SRGCmdLoadFromObject: DISPIDSPRG = DISPIDSPRG(8i32);
pub const DISPID_SRGCmdLoadFromResource: DISPIDSPRG = DISPIDSPRG(9i32);
pub const DISPID_SRGCmdLoadFromMemory: DISPIDSPRG = DISPIDSPRG(10i32);
pub const DISPID_SRGCmdLoadFromProprietaryGrammar: DISPIDSPRG = DISPIDSPRG(11i32);
pub const DISPID_SRGCmdSetRuleState: DISPIDSPRG = DISPIDSPRG(12i32);
pub const DISPID_SRGCmdSetRuleIdState: DISPIDSPRG = DISPIDSPRG(13i32);
pub const DISPID_SRGDictationLoad: DISPIDSPRG = DISPIDSPRG(14i32);
pub const DISPID_SRGDictationUnload: DISPIDSPRG = DISPIDSPRG(15i32);
pub const DISPID_SRGDictationSetState: DISPIDSPRG = DISPIDSPRG(16i32);
pub const DISPID_SRGSetWordSequenceData: DISPIDSPRG = DISPIDSPRG(17i32);
pub const DISPID_SRGSetTextSelection: DISPIDSPRG = DISPIDSPRG(18i32);
pub const DISPID_SRGIsPronounceable: DISPIDSPRG = DISPIDSPRG(19i32);
impl ::core::convert::From<i32> for DISPIDSPRG {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPIDSPRG {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPIDSPTSI(pub i32);
pub const DISPIDSPTSI_ActiveOffset: DISPIDSPTSI = DISPIDSPTSI(1i32);
pub const DISPIDSPTSI_ActiveLength: DISPIDSPTSI = DISPIDSPTSI(2i32);
pub const DISPIDSPTSI_SelectionOffset: DISPIDSPTSI = DISPIDSPTSI(3i32);
pub const DISPIDSPTSI_SelectionLength: DISPIDSPTSI = DISPIDSPTSI(4i32);
impl ::core::convert::From<i32> for DISPIDSPTSI {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPIDSPTSI {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechAudio(pub i32);
pub const DISPID_SAStatus: DISPID_SpeechAudio = DISPID_SpeechAudio(200i32);
pub const DISPID_SABufferInfo: DISPID_SpeechAudio = DISPID_SpeechAudio(201i32);
pub const DISPID_SADefaultFormat: DISPID_SpeechAudio = DISPID_SpeechAudio(202i32);
pub const DISPID_SAVolume: DISPID_SpeechAudio = DISPID_SpeechAudio(203i32);
pub const DISPID_SABufferNotifySize: DISPID_SpeechAudio = DISPID_SpeechAudio(204i32);
pub const DISPID_SAEventHandle: DISPID_SpeechAudio = DISPID_SpeechAudio(205i32);
pub const DISPID_SASetState: DISPID_SpeechAudio = DISPID_SpeechAudio(206i32);
impl ::core::convert::From<i32> for DISPID_SpeechAudio {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechAudio {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechAudioBufferInfo(pub i32);
pub const DISPID_SABIMinNotification: DISPID_SpeechAudioBufferInfo = DISPID_SpeechAudioBufferInfo(1i32);
pub const DISPID_SABIBufferSize: DISPID_SpeechAudioBufferInfo = DISPID_SpeechAudioBufferInfo(2i32);
pub const DISPID_SABIEventBias: DISPID_SpeechAudioBufferInfo = DISPID_SpeechAudioBufferInfo(3i32);
impl ::core::convert::From<i32> for DISPID_SpeechAudioBufferInfo {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechAudioBufferInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechAudioFormat(pub i32);
pub const DISPID_SAFType: DISPID_SpeechAudioFormat = DISPID_SpeechAudioFormat(1i32);
pub const DISPID_SAFGuid: DISPID_SpeechAudioFormat = DISPID_SpeechAudioFormat(2i32);
pub const DISPID_SAFGetWaveFormatEx: DISPID_SpeechAudioFormat = DISPID_SpeechAudioFormat(3i32);
pub const DISPID_SAFSetWaveFormatEx: DISPID_SpeechAudioFormat = DISPID_SpeechAudioFormat(4i32);
impl ::core::convert::From<i32> for DISPID_SpeechAudioFormat {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechAudioFormat {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechAudioStatus(pub i32);
pub const DISPID_SASFreeBufferSpace: DISPID_SpeechAudioStatus = DISPID_SpeechAudioStatus(1i32);
pub const DISPID_SASNonBlockingIO: DISPID_SpeechAudioStatus = DISPID_SpeechAudioStatus(2i32);
pub const DISPID_SASState: DISPID_SpeechAudioStatus = DISPID_SpeechAudioStatus(3i32);
pub const DISPID_SASCurrentSeekPosition: DISPID_SpeechAudioStatus = DISPID_SpeechAudioStatus(4i32);
pub const DISPID_SASCurrentDevicePosition: DISPID_SpeechAudioStatus = DISPID_SpeechAudioStatus(5i32);
impl ::core::convert::From<i32> for DISPID_SpeechAudioStatus {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechAudioStatus {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechBaseStream(pub i32);
pub const DISPID_SBSFormat: DISPID_SpeechBaseStream = DISPID_SpeechBaseStream(1i32);
pub const DISPID_SBSRead: DISPID_SpeechBaseStream = DISPID_SpeechBaseStream(2i32);
pub const DISPID_SBSWrite: DISPID_SpeechBaseStream = DISPID_SpeechBaseStream(3i32);
pub const DISPID_SBSSeek: DISPID_SpeechBaseStream = DISPID_SpeechBaseStream(4i32);
impl ::core::convert::From<i32> for DISPID_SpeechBaseStream {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechBaseStream {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechCustomStream(pub i32);
pub const DISPID_SCSBaseStream: DISPID_SpeechCustomStream = DISPID_SpeechCustomStream(100i32);
impl ::core::convert::From<i32> for DISPID_SpeechCustomStream {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechCustomStream {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechDataKey(pub i32);
pub const DISPID_SDKSetBinaryValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(1i32);
pub const DISPID_SDKGetBinaryValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(2i32);
pub const DISPID_SDKSetStringValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(3i32);
pub const DISPID_SDKGetStringValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(4i32);
pub const DISPID_SDKSetLongValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(5i32);
pub const DISPID_SDKGetlongValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(6i32);
pub const DISPID_SDKOpenKey: DISPID_SpeechDataKey = DISPID_SpeechDataKey(7i32);
pub const DISPID_SDKCreateKey: DISPID_SpeechDataKey = DISPID_SpeechDataKey(8i32);
pub const DISPID_SDKDeleteKey: DISPID_SpeechDataKey = DISPID_SpeechDataKey(9i32);
pub const DISPID_SDKDeleteValue: DISPID_SpeechDataKey = DISPID_SpeechDataKey(10i32);
pub const DISPID_SDKEnumKeys: DISPID_SpeechDataKey = DISPID_SpeechDataKey(11i32);
pub const DISPID_SDKEnumValues: DISPID_SpeechDataKey = DISPID_SpeechDataKey(12i32);
impl ::core::convert::From<i32> for DISPID_SpeechDataKey {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechDataKey {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechFileStream(pub i32);
pub const DISPID_SFSOpen: DISPID_SpeechFileStream = DISPID_SpeechFileStream(100i32);
pub const DISPID_SFSClose: DISPID_SpeechFileStream = DISPID_SpeechFileStream(101i32);
impl ::core::convert::From<i32> for DISPID_SpeechFileStream {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechFileStream {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechGrammarRule(pub i32);
pub const DISPID_SGRAttributes: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(1i32);
pub const DISPID_SGRInitialState: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(2i32);
pub const DISPID_SGRName: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(3i32);
pub const DISPID_SGRId: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(4i32);
pub const DISPID_SGRClear: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(5i32);
pub const DISPID_SGRAddResource: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(6i32);
pub const DISPID_SGRAddState: DISPID_SpeechGrammarRule = DISPID_SpeechGrammarRule(7i32);
impl ::core::convert::From<i32> for DISPID_SpeechGrammarRule {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechGrammarRule {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechGrammarRuleState(pub i32);
pub const DISPID_SGRSRule: DISPID_SpeechGrammarRuleState = DISPID_SpeechGrammarRuleState(1i32);
pub const DISPID_SGRSTransitions: DISPID_SpeechGrammarRuleState = DISPID_SpeechGrammarRuleState(2i32);
pub const DISPID_SGRSAddWordTransition: DISPID_SpeechGrammarRuleState = DISPID_SpeechGrammarRuleState(3i32);
pub const DISPID_SGRSAddRuleTransition: DISPID_SpeechGrammarRuleState = DISPID_SpeechGrammarRuleState(4i32);
pub const DISPID_SGRSAddSpecialTransition: DISPID_SpeechGrammarRuleState = DISPID_SpeechGrammarRuleState(5i32);
impl ::core::convert::From<i32> for DISPID_SpeechGrammarRuleState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechGrammarRuleState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechGrammarRuleStateTransition(pub i32);
pub const DISPID_SGRSTType: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(1i32);
pub const DISPID_SGRSTText: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(2i32);
pub const DISPID_SGRSTRule: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(3i32);
pub const DISPID_SGRSTWeight: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(4i32);
pub const DISPID_SGRSTPropertyName: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(5i32);
pub const DISPID_SGRSTPropertyId: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(6i32);
pub const DISPID_SGRSTPropertyValue: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(7i32);
pub const DISPID_SGRSTNextState: DISPID_SpeechGrammarRuleStateTransition = DISPID_SpeechGrammarRuleStateTransition(8i32);
impl ::core::convert::From<i32> for DISPID_SpeechGrammarRuleStateTransition {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechGrammarRuleStateTransition {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechGrammarRuleStateTransitions(pub i32);
pub const DISPID_SGRSTsCount: DISPID_SpeechGrammarRuleStateTransitions = DISPID_SpeechGrammarRuleStateTransitions(1i32);
pub const DISPID_SGRSTsItem: DISPID_SpeechGrammarRuleStateTransitions = DISPID_SpeechGrammarRuleStateTransitions(0i32);
pub const DISPID_SGRSTs_NewEnum: DISPID_SpeechGrammarRuleStateTransitions = DISPID_SpeechGrammarRuleStateTransitions(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechGrammarRuleStateTransitions {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechGrammarRuleStateTransitions {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechGrammarRules(pub i32);
pub const DISPID_SGRsCount: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(1i32);
pub const DISPID_SGRsDynamic: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(2i32);
pub const DISPID_SGRsAdd: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(3i32);
pub const DISPID_SGRsCommit: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(4i32);
pub const DISPID_SGRsCommitAndSave: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(5i32);
pub const DISPID_SGRsFindRule: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(6i32);
pub const DISPID_SGRsItem: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(0i32);
pub const DISPID_SGRs_NewEnum: DISPID_SpeechGrammarRules = DISPID_SpeechGrammarRules(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechGrammarRules {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechGrammarRules {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechLexicon(pub i32);
pub const DISPID_SLGenerationId: DISPID_SpeechLexicon = DISPID_SpeechLexicon(1i32);
pub const DISPID_SLGetWords: DISPID_SpeechLexicon = DISPID_SpeechLexicon(2i32);
pub const DISPID_SLAddPronunciation: DISPID_SpeechLexicon = DISPID_SpeechLexicon(3i32);
pub const DISPID_SLAddPronunciationByPhoneIds: DISPID_SpeechLexicon = DISPID_SpeechLexicon(4i32);
pub const DISPID_SLRemovePronunciation: DISPID_SpeechLexicon = DISPID_SpeechLexicon(5i32);
pub const DISPID_SLRemovePronunciationByPhoneIds: DISPID_SpeechLexicon = DISPID_SpeechLexicon(6i32);
pub const DISPID_SLGetPronunciations: DISPID_SpeechLexicon = DISPID_SpeechLexicon(7i32);
pub const DISPID_SLGetGenerationChange: DISPID_SpeechLexicon = DISPID_SpeechLexicon(8i32);
impl ::core::convert::From<i32> for DISPID_SpeechLexicon {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechLexicon {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechLexiconProns(pub i32);
pub const DISPID_SLPsCount: DISPID_SpeechLexiconProns = DISPID_SpeechLexiconProns(1i32);
pub const DISPID_SLPsItem: DISPID_SpeechLexiconProns = DISPID_SpeechLexiconProns(0i32);
pub const DISPID_SLPs_NewEnum: DISPID_SpeechLexiconProns = DISPID_SpeechLexiconProns(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechLexiconProns {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechLexiconProns {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechLexiconPronunciation(pub i32);
pub const DISPID_SLPType: DISPID_SpeechLexiconPronunciation = DISPID_SpeechLexiconPronunciation(1i32);
pub const DISPID_SLPLangId: DISPID_SpeechLexiconPronunciation = DISPID_SpeechLexiconPronunciation(2i32);
pub const DISPID_SLPPartOfSpeech: DISPID_SpeechLexiconPronunciation = DISPID_SpeechLexiconPronunciation(3i32);
pub const DISPID_SLPPhoneIds: DISPID_SpeechLexiconPronunciation = DISPID_SpeechLexiconPronunciation(4i32);
pub const DISPID_SLPSymbolic: DISPID_SpeechLexiconPronunciation = DISPID_SpeechLexiconPronunciation(5i32);
impl ::core::convert::From<i32> for DISPID_SpeechLexiconPronunciation {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechLexiconPronunciation {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechLexiconWord(pub i32);
pub const DISPID_SLWLangId: DISPID_SpeechLexiconWord = DISPID_SpeechLexiconWord(1i32);
pub const DISPID_SLWType: DISPID_SpeechLexiconWord = DISPID_SpeechLexiconWord(2i32);
pub const DISPID_SLWWord: DISPID_SpeechLexiconWord = DISPID_SpeechLexiconWord(3i32);
pub const DISPID_SLWPronunciations: DISPID_SpeechLexiconWord = DISPID_SpeechLexiconWord(4i32);
impl ::core::convert::From<i32> for DISPID_SpeechLexiconWord {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechLexiconWord {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechLexiconWords(pub i32);
pub const DISPID_SLWsCount: DISPID_SpeechLexiconWords = DISPID_SpeechLexiconWords(1i32);
pub const DISPID_SLWsItem: DISPID_SpeechLexiconWords = DISPID_SpeechLexiconWords(0i32);
pub const DISPID_SLWs_NewEnum: DISPID_SpeechLexiconWords = DISPID_SpeechLexiconWords(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechLexiconWords {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechLexiconWords {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechMMSysAudio(pub i32);
pub const DISPID_SMSADeviceId: DISPID_SpeechMMSysAudio = DISPID_SpeechMMSysAudio(300i32);
pub const DISPID_SMSALineId: DISPID_SpeechMMSysAudio = DISPID_SpeechMMSysAudio(301i32);
pub const DISPID_SMSAMMHandle: DISPID_SpeechMMSysAudio = DISPID_SpeechMMSysAudio(302i32);
impl ::core::convert::From<i32> for DISPID_SpeechMMSysAudio {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechMMSysAudio {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechMemoryStream(pub i32);
pub const DISPID_SMSSetData: DISPID_SpeechMemoryStream = DISPID_SpeechMemoryStream(100i32);
pub const DISPID_SMSGetData: DISPID_SpeechMemoryStream = DISPID_SpeechMemoryStream(101i32);
impl ::core::convert::From<i32> for DISPID_SpeechMemoryStream {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechMemoryStream {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechObjectToken(pub i32);
pub const DISPID_SOTId: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(1i32);
pub const DISPID_SOTDataKey: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(2i32);
pub const DISPID_SOTCategory: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(3i32);
pub const DISPID_SOTGetDescription: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(4i32);
pub const DISPID_SOTSetId: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(5i32);
pub const DISPID_SOTGetAttribute: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(6i32);
pub const DISPID_SOTCreateInstance: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(7i32);
pub const DISPID_SOTRemove: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(8i32);
pub const DISPID_SOTGetStorageFileName: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(9i32);
pub const DISPID_SOTRemoveStorageFileName: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(10i32);
pub const DISPID_SOTIsUISupported: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(11i32);
pub const DISPID_SOTDisplayUI: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(12i32);
pub const DISPID_SOTMatchesAttributes: DISPID_SpeechObjectToken = DISPID_SpeechObjectToken(13i32);
impl ::core::convert::From<i32> for DISPID_SpeechObjectToken {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechObjectToken {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechObjectTokenCategory(pub i32);
pub const DISPID_SOTCId: DISPID_SpeechObjectTokenCategory = DISPID_SpeechObjectTokenCategory(1i32);
pub const DISPID_SOTCDefault: DISPID_SpeechObjectTokenCategory = DISPID_SpeechObjectTokenCategory(2i32);
pub const DISPID_SOTCSetId: DISPID_SpeechObjectTokenCategory = DISPID_SpeechObjectTokenCategory(3i32);
pub const DISPID_SOTCGetDataKey: DISPID_SpeechObjectTokenCategory = DISPID_SpeechObjectTokenCategory(4i32);
pub const DISPID_SOTCEnumerateTokens: DISPID_SpeechObjectTokenCategory = DISPID_SpeechObjectTokenCategory(5i32);
impl ::core::convert::From<i32> for DISPID_SpeechObjectTokenCategory {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechObjectTokenCategory {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechObjectTokens(pub i32);
pub const DISPID_SOTsCount: DISPID_SpeechObjectTokens = DISPID_SpeechObjectTokens(1i32);
pub const DISPID_SOTsItem: DISPID_SpeechObjectTokens = DISPID_SpeechObjectTokens(0i32);
pub const DISPID_SOTs_NewEnum: DISPID_SpeechObjectTokens = DISPID_SpeechObjectTokens(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechObjectTokens {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechObjectTokens {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhoneConverter(pub i32);
pub const DISPID_SPCLangId: DISPID_SpeechPhoneConverter = DISPID_SpeechPhoneConverter(1i32);
pub const DISPID_SPCPhoneToId: DISPID_SpeechPhoneConverter = DISPID_SpeechPhoneConverter(2i32);
pub const DISPID_SPCIdToPhone: DISPID_SpeechPhoneConverter = DISPID_SpeechPhoneConverter(3i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhoneConverter {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhoneConverter {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseAlternate(pub i32);
pub const DISPID_SPARecoResult: DISPID_SpeechPhraseAlternate = DISPID_SpeechPhraseAlternate(1i32);
pub const DISPID_SPAStartElementInResult: DISPID_SpeechPhraseAlternate = DISPID_SpeechPhraseAlternate(2i32);
pub const DISPID_SPANumberOfElementsInResult: DISPID_SpeechPhraseAlternate = DISPID_SpeechPhraseAlternate(3i32);
pub const DISPID_SPAPhraseInfo: DISPID_SpeechPhraseAlternate = DISPID_SpeechPhraseAlternate(4i32);
pub const DISPID_SPACommit: DISPID_SpeechPhraseAlternate = DISPID_SpeechPhraseAlternate(5i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseAlternate {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseAlternate {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseAlternates(pub i32);
pub const DISPID_SPAsCount: DISPID_SpeechPhraseAlternates = DISPID_SpeechPhraseAlternates(1i32);
pub const DISPID_SPAsItem: DISPID_SpeechPhraseAlternates = DISPID_SpeechPhraseAlternates(0i32);
pub const DISPID_SPAs_NewEnum: DISPID_SpeechPhraseAlternates = DISPID_SpeechPhraseAlternates(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseAlternates {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseAlternates {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseBuilder(pub i32);
pub const DISPID_SPPBRestorePhraseFromMemory: DISPID_SpeechPhraseBuilder = DISPID_SpeechPhraseBuilder(1i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseBuilder {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseBuilder {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseElement(pub i32);
pub const DISPID_SPEAudioTimeOffset: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(1i32);
pub const DISPID_SPEAudioSizeTime: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(2i32);
pub const DISPID_SPEAudioStreamOffset: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(3i32);
pub const DISPID_SPEAudioSizeBytes: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(4i32);
pub const DISPID_SPERetainedStreamOffset: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(5i32);
pub const DISPID_SPERetainedSizeBytes: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(6i32);
pub const DISPID_SPEDisplayText: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(7i32);
pub const DISPID_SPELexicalForm: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(8i32);
pub const DISPID_SPEPronunciation: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(9i32);
pub const DISPID_SPEDisplayAttributes: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(10i32);
pub const DISPID_SPERequiredConfidence: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(11i32);
pub const DISPID_SPEActualConfidence: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(12i32);
pub const DISPID_SPEEngineConfidence: DISPID_SpeechPhraseElement = DISPID_SpeechPhraseElement(13i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseElement {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseElement {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseElements(pub i32);
pub const DISPID_SPEsCount: DISPID_SpeechPhraseElements = DISPID_SpeechPhraseElements(1i32);
pub const DISPID_SPEsItem: DISPID_SpeechPhraseElements = DISPID_SpeechPhraseElements(0i32);
pub const DISPID_SPEs_NewEnum: DISPID_SpeechPhraseElements = DISPID_SpeechPhraseElements(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseElements {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseElements {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseInfo(pub i32);
pub const DISPID_SPILanguageId: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(1i32);
pub const DISPID_SPIGrammarId: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(2i32);
pub const DISPID_SPIStartTime: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(3i32);
pub const DISPID_SPIAudioStreamPosition: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(4i32);
pub const DISPID_SPIAudioSizeBytes: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(5i32);
pub const DISPID_SPIRetainedSizeBytes: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(6i32);
pub const DISPID_SPIAudioSizeTime: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(7i32);
pub const DISPID_SPIRule: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(8i32);
pub const DISPID_SPIProperties: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(9i32);
pub const DISPID_SPIElements: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(10i32);
pub const DISPID_SPIReplacements: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(11i32);
pub const DISPID_SPIEngineId: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(12i32);
pub const DISPID_SPIEnginePrivateData: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(13i32);
pub const DISPID_SPISaveToMemory: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(14i32);
pub const DISPID_SPIGetText: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(15i32);
pub const DISPID_SPIGetDisplayAttributes: DISPID_SpeechPhraseInfo = DISPID_SpeechPhraseInfo(16i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseInfo {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseInfo {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseProperties(pub i32);
pub const DISPID_SPPsCount: DISPID_SpeechPhraseProperties = DISPID_SpeechPhraseProperties(1i32);
pub const DISPID_SPPsItem: DISPID_SpeechPhraseProperties = DISPID_SpeechPhraseProperties(0i32);
pub const DISPID_SPPs_NewEnum: DISPID_SpeechPhraseProperties = DISPID_SpeechPhraseProperties(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseProperties {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseProperties {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseProperty(pub i32);
pub const DISPID_SPPName: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(1i32);
pub const DISPID_SPPId: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(2i32);
pub const DISPID_SPPValue: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(3i32);
pub const DISPID_SPPFirstElement: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(4i32);
pub const DISPID_SPPNumberOfElements: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(5i32);
pub const DISPID_SPPEngineConfidence: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(6i32);
pub const DISPID_SPPConfidence: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(7i32);
pub const DISPID_SPPParent: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(8i32);
pub const DISPID_SPPChildren: DISPID_SpeechPhraseProperty = DISPID_SpeechPhraseProperty(9i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseProperty {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseProperty {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseReplacement(pub i32);
pub const DISPID_SPRDisplayAttributes: DISPID_SpeechPhraseReplacement = DISPID_SpeechPhraseReplacement(1i32);
pub const DISPID_SPRText: DISPID_SpeechPhraseReplacement = DISPID_SpeechPhraseReplacement(2i32);
pub const DISPID_SPRFirstElement: DISPID_SpeechPhraseReplacement = DISPID_SpeechPhraseReplacement(3i32);
pub const DISPID_SPRNumberOfElements: DISPID_SpeechPhraseReplacement = DISPID_SpeechPhraseReplacement(4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseReplacement {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseReplacement {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseReplacements(pub i32);
pub const DISPID_SPRsCount: DISPID_SpeechPhraseReplacements = DISPID_SpeechPhraseReplacements(1i32);
pub const DISPID_SPRsItem: DISPID_SpeechPhraseReplacements = DISPID_SpeechPhraseReplacements(0i32);
pub const DISPID_SPRs_NewEnum: DISPID_SpeechPhraseReplacements = DISPID_SpeechPhraseReplacements(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseReplacements {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseReplacements {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseRule(pub i32);
pub const DISPID_SPRuleName: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(1i32);
pub const DISPID_SPRuleId: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(2i32);
pub const DISPID_SPRuleFirstElement: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(3i32);
pub const DISPID_SPRuleNumberOfElements: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(4i32);
pub const DISPID_SPRuleParent: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(5i32);
pub const DISPID_SPRuleChildren: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(6i32);
pub const DISPID_SPRuleConfidence: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(7i32);
pub const DISPID_SPRuleEngineConfidence: DISPID_SpeechPhraseRule = DISPID_SpeechPhraseRule(8i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseRule {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseRule {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechPhraseRules(pub i32);
pub const DISPID_SPRulesCount: DISPID_SpeechPhraseRules = DISPID_SpeechPhraseRules(1i32);
pub const DISPID_SPRulesItem: DISPID_SpeechPhraseRules = DISPID_SpeechPhraseRules(0i32);
pub const DISPID_SPRules_NewEnum: DISPID_SpeechPhraseRules = DISPID_SpeechPhraseRules(-4i32);
impl ::core::convert::From<i32> for DISPID_SpeechPhraseRules {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechPhraseRules {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecoContext(pub i32);
pub const DISPID_SRCRecognizer: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(1i32);
pub const DISPID_SRCAudioInInterferenceStatus: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(2i32);
pub const DISPID_SRCRequestedUIType: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(3i32);
pub const DISPID_SRCVoice: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(4i32);
pub const DISPID_SRAllowVoiceFormatMatchingOnNextSet: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(5i32);
pub const DISPID_SRCVoicePurgeEvent: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(6i32);
pub const DISPID_SRCEventInterests: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(7i32);
pub const DISPID_SRCCmdMaxAlternates: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(8i32);
pub const DISPID_SRCState: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(9i32);
pub const DISPID_SRCRetainedAudio: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(10i32);
pub const DISPID_SRCRetainedAudioFormat: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(11i32);
pub const DISPID_SRCPause: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(12i32);
pub const DISPID_SRCResume: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(13i32);
pub const DISPID_SRCCreateGrammar: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(14i32);
pub const DISPID_SRCCreateResultFromMemory: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(15i32);
pub const DISPID_SRCBookmark: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(16i32);
pub const DISPID_SRCSetAdaptationData: DISPID_SpeechRecoContext = DISPID_SpeechRecoContext(17i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecoContext {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecoContext {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecoContextEvents(pub i32);
pub const DISPID_SRCEStartStream: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(1i32);
pub const DISPID_SRCEEndStream: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(2i32);
pub const DISPID_SRCEBookmark: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(3i32);
pub const DISPID_SRCESoundStart: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(4i32);
pub const DISPID_SRCESoundEnd: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(5i32);
pub const DISPID_SRCEPhraseStart: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(6i32);
pub const DISPID_SRCERecognition: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(7i32);
pub const DISPID_SRCEHypothesis: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(8i32);
pub const DISPID_SRCEPropertyNumberChange: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(9i32);
pub const DISPID_SRCEPropertyStringChange: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(10i32);
pub const DISPID_SRCEFalseRecognition: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(11i32);
pub const DISPID_SRCEInterference: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(12i32);
pub const DISPID_SRCERequestUI: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(13i32);
pub const DISPID_SRCERecognizerStateChange: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(14i32);
pub const DISPID_SRCEAdaptation: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(15i32);
pub const DISPID_SRCERecognitionForOtherContext: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(16i32);
pub const DISPID_SRCEAudioLevel: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(17i32);
pub const DISPID_SRCEEnginePrivate: DISPID_SpeechRecoContextEvents = DISPID_SpeechRecoContextEvents(18i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecoContextEvents {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecoContextEvents {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecoResult(pub i32);
pub const DISPID_SRRRecoContext: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(1i32);
pub const DISPID_SRRTimes: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(2i32);
pub const DISPID_SRRAudioFormat: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(3i32);
pub const DISPID_SRRPhraseInfo: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(4i32);
pub const DISPID_SRRAlternates: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(5i32);
pub const DISPID_SRRAudio: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(6i32);
pub const DISPID_SRRSpeakAudio: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(7i32);
pub const DISPID_SRRSaveToMemory: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(8i32);
pub const DISPID_SRRDiscardResultInfo: DISPID_SpeechRecoResult = DISPID_SpeechRecoResult(9i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecoResult {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecoResult {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecoResult2(pub i32);
pub const DISPID_SRRSetTextFeedback: DISPID_SpeechRecoResult2 = DISPID_SpeechRecoResult2(12i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecoResult2 {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecoResult2 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecoResultTimes(pub i32);
pub const DISPID_SRRTStreamTime: DISPID_SpeechRecoResultTimes = DISPID_SpeechRecoResultTimes(1i32);
pub const DISPID_SRRTLength: DISPID_SpeechRecoResultTimes = DISPID_SpeechRecoResultTimes(2i32);
pub const DISPID_SRRTTickCount: DISPID_SpeechRecoResultTimes = DISPID_SpeechRecoResultTimes(3i32);
pub const DISPID_SRRTOffsetFromStart: DISPID_SpeechRecoResultTimes = DISPID_SpeechRecoResultTimes(4i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecoResultTimes {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecoResultTimes {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecognizer(pub i32);
pub const DISPID_SRRecognizer: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(1i32);
pub const DISPID_SRAllowAudioInputFormatChangesOnNextSet: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(2i32);
pub const DISPID_SRAudioInput: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(3i32);
pub const DISPID_SRAudioInputStream: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(4i32);
pub const DISPID_SRIsShared: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(5i32);
pub const DISPID_SRState: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(6i32);
pub const DISPID_SRStatus: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(7i32);
pub const DISPID_SRProfile: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(8i32);
pub const DISPID_SREmulateRecognition: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(9i32);
pub const DISPID_SRCreateRecoContext: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(10i32);
pub const DISPID_SRGetFormat: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(11i32);
pub const DISPID_SRSetPropertyNumber: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(12i32);
pub const DISPID_SRGetPropertyNumber: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(13i32);
pub const DISPID_SRSetPropertyString: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(14i32);
pub const DISPID_SRGetPropertyString: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(15i32);
pub const DISPID_SRIsUISupported: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(16i32);
pub const DISPID_SRDisplayUI: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(17i32);
pub const DISPID_SRGetRecognizers: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(18i32);
pub const DISPID_SVGetAudioInputs: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(19i32);
pub const DISPID_SVGetProfiles: DISPID_SpeechRecognizer = DISPID_SpeechRecognizer(20i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecognizer {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecognizer {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechRecognizerStatus(pub i32);
pub const DISPID_SRSAudioStatus: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(1i32);
pub const DISPID_SRSCurrentStreamPosition: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(2i32);
pub const DISPID_SRSCurrentStreamNumber: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(3i32);
pub const DISPID_SRSNumberOfActiveRules: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(4i32);
pub const DISPID_SRSClsidEngine: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(5i32);
pub const DISPID_SRSSupportedLanguages: DISPID_SpeechRecognizerStatus = DISPID_SpeechRecognizerStatus(6i32);
impl ::core::convert::From<i32> for DISPID_SpeechRecognizerStatus {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechRecognizerStatus {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechVoice(pub i32);
pub const DISPID_SVStatus: DISPID_SpeechVoice = DISPID_SpeechVoice(1i32);
pub const DISPID_SVVoice: DISPID_SpeechVoice = DISPID_SpeechVoice(2i32);
pub const DISPID_SVAudioOutput: DISPID_SpeechVoice = DISPID_SpeechVoice(3i32);
pub const DISPID_SVAudioOutputStream: DISPID_SpeechVoice = DISPID_SpeechVoice(4i32);
pub const DISPID_SVRate: DISPID_SpeechVoice = DISPID_SpeechVoice(5i32);
pub const DISPID_SVVolume: DISPID_SpeechVoice = DISPID_SpeechVoice(6i32);
pub const DISPID_SVAllowAudioOuputFormatChangesOnNextSet: DISPID_SpeechVoice = DISPID_SpeechVoice(7i32);
pub const DISPID_SVEventInterests: DISPID_SpeechVoice = DISPID_SpeechVoice(8i32);
pub const DISPID_SVPriority: DISPID_SpeechVoice = DISPID_SpeechVoice(9i32);
pub const DISPID_SVAlertBoundary: DISPID_SpeechVoice = DISPID_SpeechVoice(10i32);
pub const DISPID_SVSyncronousSpeakTimeout: DISPID_SpeechVoice = DISPID_SpeechVoice(11i32);
pub const DISPID_SVSpeak: DISPID_SpeechVoice = DISPID_SpeechVoice(12i32);
pub const DISPID_SVSpeakStream: DISPID_SpeechVoice = DISPID_SpeechVoice(13i32);
pub const DISPID_SVPause: DISPID_SpeechVoice = DISPID_SpeechVoice(14i32);
pub const DISPID_SVResume: DISPID_SpeechVoice = DISPID_SpeechVoice(15i32);
pub const DISPID_SVSkip: DISPID_SpeechVoice = DISPID_SpeechVoice(16i32);
pub const DISPID_SVGetVoices: DISPID_SpeechVoice = DISPID_SpeechVoice(17i32);
pub const DISPID_SVGetAudioOutputs: DISPID_SpeechVoice = DISPID_SpeechVoice(18i32);
pub const DISPID_SVWaitUntilDone: DISPID_SpeechVoice = DISPID_SpeechVoice(19i32);
pub const DISPID_SVSpeakCompleteEvent: DISPID_SpeechVoice = DISPID_SpeechVoice(20i32);
pub const DISPID_SVIsUISupported: DISPID_SpeechVoice = DISPID_SpeechVoice(21i32);
pub const DISPID_SVDisplayUI: DISPID_SpeechVoice = DISPID_SpeechVoice(22i32);
impl ::core::convert::From<i32> for DISPID_SpeechVoice {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechVoice {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechVoiceEvent(pub i32);
pub const DISPID_SVEStreamStart: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(1i32);
pub const DISPID_SVEStreamEnd: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(2i32);
pub const DISPID_SVEVoiceChange: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(3i32);
pub const DISPID_SVEBookmark: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(4i32);
pub const DISPID_SVEWord: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(5i32);
pub const DISPID_SVEPhoneme: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(6i32);
pub const DISPID_SVESentenceBoundary: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(7i32);
pub const DISPID_SVEViseme: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(8i32);
pub const DISPID_SVEAudioLevel: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(9i32);
pub const DISPID_SVEEnginePrivate: DISPID_SpeechVoiceEvent = DISPID_SpeechVoiceEvent(10i32);
impl ::core::convert::From<i32> for DISPID_SpeechVoiceEvent {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechVoiceEvent {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechVoiceStatus(pub i32);
pub const DISPID_SVSCurrentStreamNumber: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(1i32);
pub const DISPID_SVSLastStreamNumberQueued: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(2i32);
pub const DISPID_SVSLastResult: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(3i32);
pub const DISPID_SVSRunningState: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(4i32);
pub const DISPID_SVSInputWordPosition: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(5i32);
pub const DISPID_SVSInputWordLength: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(6i32);
pub const DISPID_SVSInputSentencePosition: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(7i32);
pub const DISPID_SVSInputSentenceLength: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(8i32);
pub const DISPID_SVSLastBookmark: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(9i32);
pub const DISPID_SVSLastBookmarkId: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(10i32);
pub const DISPID_SVSPhonemeId: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(11i32);
pub const DISPID_SVSVisemeId: DISPID_SpeechVoiceStatus = DISPID_SpeechVoiceStatus(12i32);
impl ::core::convert::From<i32> for DISPID_SpeechVoiceStatus {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechVoiceStatus {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechWaveFormatEx(pub i32);
pub const DISPID_SWFEFormatTag: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(1i32);
pub const DISPID_SWFEChannels: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(2i32);
pub const DISPID_SWFESamplesPerSec: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(3i32);
pub const DISPID_SWFEAvgBytesPerSec: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(4i32);
pub const DISPID_SWFEBlockAlign: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(5i32);
pub const DISPID_SWFEBitsPerSample: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(6i32);
pub const DISPID_SWFEExtraData: DISPID_SpeechWaveFormatEx = DISPID_SpeechWaveFormatEx(7i32);
impl ::core::convert::From<i32> for DISPID_SpeechWaveFormatEx {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechWaveFormatEx {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct DISPID_SpeechXMLRecoResult(pub i32);
pub const DISPID_SRRGetXMLResult: DISPID_SpeechXMLRecoResult = DISPID_SpeechXMLRecoResult(10i32);
pub const DISPID_SRRGetXMLErrorInfo: DISPID_SpeechXMLRecoResult = DISPID_SpeechXMLRecoResult(11i32);
impl ::core::convert::From<i32> for DISPID_SpeechXMLRecoResult {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for DISPID_SpeechXMLRecoResult {
type Abi = Self;
}
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct IEnumSpObjectTokens(pub ::windows::core::IUnknown);
impl IEnumSpObjectTokens {
pub unsafe fn Next(&self, celt: u32, pelt: *mut ::core::option::Option<ISpObjectToken>, pceltfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt), ::core::mem::transmute(pelt), ::core::mem::transmute(pceltfetched)).ok()
}
pub unsafe fn Skip(&self, celt: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(celt)).ok()
}
pub unsafe fn Reset(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Clone(&self) -> ::windows::core::Result<IEnumSpObjectTokens> {
let mut result__: <IEnumSpObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<IEnumSpObjectTokens>(result__)
}
pub unsafe fn Item(&self, index: u32) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpObjectToken>(result__)
}
pub unsafe fn GetCount(&self, pcount: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcount)).ok()
}
}
unsafe impl ::windows::core::Interface for IEnumSpObjectTokens {
type Vtable = IEnumSpObjectTokens_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x06b64f9e_7fda_11d2_b4f2_00c04f797396);
}
impl ::core::convert::From<IEnumSpObjectTokens> for ::windows::core::IUnknown {
fn from(value: IEnumSpObjectTokens) -> Self {
value.0
}
}
impl ::core::convert::From<&IEnumSpObjectTokens> for ::windows::core::IUnknown {
fn from(value: &IEnumSpObjectTokens) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for IEnumSpObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a IEnumSpObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct IEnumSpObjectTokens_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32, pelt: *mut ::windows::core::RawPtr, pceltfetched: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, celt: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcount: *mut u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpAudio(pub ::windows::core::IUnknown);
impl ISpAudio {
pub unsafe fn Read(&self, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn Write(&self, pv: *const ::core::ffi::c_void, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Seek(&self, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dlibmove), ::core::mem::transmute(dworigin), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetSize(&self, libnewsize: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(libnewsize)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CopyTo<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstm: Param0, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstm.into_param().abi(), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread), ::core::mem::transmute(pcbwritten)).ok()
}
pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(grfcommitflags)).ok()
}
pub unsafe fn Revert(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn Stat(&self, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatstg), ::core::mem::transmute(grfstatflag)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Clone(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, pguidformatid: *const ::windows::core::GUID) -> ::windows::core::Result<*mut super::Audio::WAVEFORMATEX> {
let mut result__: <*mut super::Audio::WAVEFORMATEX as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidformatid), &mut result__).from_abi::<*mut super::Audio::WAVEFORMATEX>(result__)
}
pub unsafe fn SetState(&self, newstate: SPAUDIOSTATE, ullreserved: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(newstate), ::core::mem::transmute(ullreserved)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn SetFormat(&self, rguidfmtid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidfmtid), ::core::mem::transmute(pwaveformatex)).ok()
}
pub unsafe fn GetStatus(&self, pstatus: *mut SPAUDIOSTATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus)).ok()
}
pub unsafe fn SetBufferInfo(&self, pbuffinfo: *const SPAUDIOBUFFERINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbuffinfo)).ok()
}
pub unsafe fn GetBufferInfo(&self, pbuffinfo: *mut SPAUDIOBUFFERINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbuffinfo)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetDefaultFormat(&self, pformatid: *mut ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(pformatid), ::core::mem::transmute(ppcomemwaveformatex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetVolumeLevel(&self, plevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(plevel)).ok()
}
pub unsafe fn SetVolumeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetBufferNotifySize(&self, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn SetBufferNotifySize(&self, cbsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(cbsize)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpAudio {
type Vtable = ISpAudio_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc05c768f_fae8_4ec2_8e07_338321c12452);
}
impl ::core::convert::From<ISpAudio> for ::windows::core::IUnknown {
fn from(value: ISpAudio) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpAudio> for ::windows::core::IUnknown {
fn from(value: &ISpAudio) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpAudio> for ISpStreamFormat {
fn from(value: ISpAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpAudio> for ISpStreamFormat {
fn from(value: &ISpAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for &ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpAudio> for super::super::System::Com::IStream {
fn from(value: ISpAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpAudio> for super::super::System::Com::IStream {
fn from(value: &ISpAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for &ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpAudio> for super::super::System::Com::ISequentialStream {
fn from(value: ISpAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpAudio> for super::super::System::Com::ISequentialStream {
fn from(value: &ISpAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for &ISpAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpAudio_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *const ::core::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK, plibnewposition: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, libnewsize: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstm: ::windows::core::RawPtr, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grfcommitflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstm: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidformatid: *const ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newstate: SPAUDIOSTATE, ullreserved: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidfmtid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut SPAUDIOSTATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffinfo: *const SPAUDIOBUFFERINFO) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffinfo: *mut SPAUDIOBUFFERINFO) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pformatid: *mut ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cbsize: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpContainerLexicon(pub ::windows::core::IUnknown);
impl ISpContainerLexicon {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPronunciations<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, dwflags: u32, pwordpronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(dwflags), ::core::mem::transmute(pwordpronunciationlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddPronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(epartofspeech), ::core::mem::transmute(pszpronunciation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemovePronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(epartofspeech), ::core::mem::transmute(pszpronunciation)).ok()
}
pub unsafe fn GetGeneration(&self, pdwgeneration: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetGenerationChange(&self, dwflags: u32, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pwordlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWords(&self, dwflags: u32, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pdwcookie), ::core::mem::transmute(pwordlist)).ok()
}
pub unsafe fn AddLexicon<'a, Param0: ::windows::core::IntoParam<'a, ISpLexicon>>(&self, paddlexicon: Param0, dwflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), paddlexicon.into_param().abi(), ::core::mem::transmute(dwflags)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpContainerLexicon {
type Vtable = ISpContainerLexicon_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8565572f_c094_41cc_b56e_10bd9c3ff044);
}
impl ::core::convert::From<ISpContainerLexicon> for ::windows::core::IUnknown {
fn from(value: ISpContainerLexicon) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpContainerLexicon> for ::windows::core::IUnknown {
fn from(value: &ISpContainerLexicon) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpContainerLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpContainerLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpContainerLexicon> for ISpLexicon {
fn from(value: ISpContainerLexicon) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpContainerLexicon> for ISpLexicon {
fn from(value: &ISpContainerLexicon) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpLexicon> for ISpContainerLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ISpLexicon> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpLexicon> for &ISpContainerLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ISpLexicon> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpContainerLexicon_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, dwflags: u32, pwordpronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paddlexicon: ::windows::core::RawPtr, dwflags: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpDataKey(pub ::windows::core::IUnknown);
impl ISpDataKey {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, cbdata: u32, pdata: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(cbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), pszvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, dwvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(dwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pdwvalue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pdwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkeyname: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pszsubkeyname.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpDataKey {
type Vtable = ISpDataKey_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14056581_e16c_11d2_bb90_00c04f8ee6c0);
}
impl ::core::convert::From<ISpDataKey> for ::windows::core::IUnknown {
fn from(value: ISpDataKey) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpDataKey> for ::windows::core::IUnknown {
fn from(value: &ISpDataKey) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpDataKey_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, cbdata: u32, pdata: *const u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, ppszvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, dwvalue: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkeyname: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszsubkeyname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszvaluename: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpDisplayAlternates(pub ::windows::core::IUnknown);
impl ISpDisplayAlternates {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDisplayAlternates(&self, pphrase: *const SPDISPLAYPHRASE, crequestcount: u32, ppcomemphrases: *mut *mut SPDISPLAYPHRASE, pcphrasesreturned: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pphrase), ::core::mem::transmute(crequestcount), ::core::mem::transmute(ppcomemphrases), ::core::mem::transmute(pcphrasesreturned)).ok()
}
pub unsafe fn SetFullStopTrailSpace(&self, ultrailspace: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(ultrailspace)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpDisplayAlternates {
type Vtable = ISpDisplayAlternates_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc8d7c7e2_0dde_44b7_afe3_b0c991fbeb5e);
}
impl ::core::convert::From<ISpDisplayAlternates> for ::windows::core::IUnknown {
fn from(value: ISpDisplayAlternates) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpDisplayAlternates> for ::windows::core::IUnknown {
fn from(value: &ISpDisplayAlternates) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpDisplayAlternates {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpDisplayAlternates {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpDisplayAlternates_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pphrase: *const SPDISPLAYPHRASE, crequestcount: u32, ppcomemphrases: *mut *mut SPDISPLAYPHRASE, pcphrasesreturned: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ultrailspace: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpEnginePronunciation(pub ::windows::core::IUnknown);
impl ISpEnginePronunciation {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Normalize<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, pszleftcontext: Param1, pszrightcontext: Param2, langid: u16, pnormalizationlist: *mut SPNORMALIZATIONLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszword.into_param().abi(), pszleftcontext.into_param().abi(), pszrightcontext.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(pnormalizationlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPronunciations<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, pszleftcontext: Param1, pszrightcontext: Param2, langid: u16, penginepronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszword.into_param().abi(), pszleftcontext.into_param().abi(), pszrightcontext.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(penginepronunciationlist)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpEnginePronunciation {
type Vtable = ISpEnginePronunciation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc360ce4b_76d1_4214_ad68_52657d5083da);
}
impl ::core::convert::From<ISpEnginePronunciation> for ::windows::core::IUnknown {
fn from(value: ISpEnginePronunciation) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpEnginePronunciation> for ::windows::core::IUnknown {
fn from(value: &ISpEnginePronunciation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpEnginePronunciation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpEnginePronunciation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpEnginePronunciation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, pszleftcontext: super::super::Foundation::PWSTR, pszrightcontext: super::super::Foundation::PWSTR, langid: u16, pnormalizationlist: *mut SPNORMALIZATIONLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, pszleftcontext: super::super::Foundation::PWSTR, pszrightcontext: super::super::Foundation::PWSTR, langid: u16, penginepronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpEventSink(pub ::windows::core::IUnknown);
impl ISpEventSink {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddEvents(&self, peventarray: *const SPEVENT, ulcount: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(peventarray), ::core::mem::transmute(ulcount)).ok()
}
pub unsafe fn GetEventInterest(&self, pulleventinterest: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pulleventinterest)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpEventSink {
type Vtable = ISpEventSink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbe7a9cc9_5f9e_11d2_960f_00c04f8ee628);
}
impl ::core::convert::From<ISpEventSink> for ::windows::core::IUnknown {
fn from(value: ISpEventSink) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpEventSink> for ::windows::core::IUnknown {
fn from(value: &ISpEventSink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpEventSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpEventSink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpEventSink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peventarray: *const SPEVENT, ulcount: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulleventinterest: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpEventSource(pub ::windows::core::IUnknown);
impl ISpEventSource {
pub unsafe fn SetNotifySink<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifySink>>(&self, pnotifysink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotifysink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackInterface<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
pub unsafe fn SetNotifyWin32Event(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WaitForNotifyEvent(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNotifyEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetInterest(&self, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulleventinterest), ::core::mem::transmute(ullqueuedinterest)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEvents(&self, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcount), ::core::mem::transmute(peventarray), ::core::mem::transmute(pulfetched)).ok()
}
pub unsafe fn GetInfo(&self, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinfo)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpEventSource {
type Vtable = ISpEventSource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbe7a9cce_5f9e_11d2_960f_00c04f8ee628);
}
impl ::core::convert::From<ISpEventSource> for ::windows::core::IUnknown {
fn from(value: ISpEventSource) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpEventSource> for ::windows::core::IUnknown {
fn from(value: &ISpEventSource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpEventSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpEventSource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpEventSource> for ISpNotifySource {
fn from(value: ISpEventSource) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpEventSource> for ISpNotifySource {
fn from(value: &ISpEventSource) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for ISpEventSource {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for &ISpEventSource {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpEventSource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotifysink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpEventSource2(pub ::windows::core::IUnknown);
impl ISpEventSource2 {
pub unsafe fn SetNotifySink<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifySink>>(&self, pnotifysink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotifysink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackInterface<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
pub unsafe fn SetNotifyWin32Event(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WaitForNotifyEvent(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNotifyEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetInterest(&self, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulleventinterest), ::core::mem::transmute(ullqueuedinterest)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEvents(&self, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcount), ::core::mem::transmute(peventarray), ::core::mem::transmute(pulfetched)).ok()
}
pub unsafe fn GetInfo(&self, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinfo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventsEx(&self, ulcount: u32, peventarray: *mut SPEVENTEX, pulfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcount), ::core::mem::transmute(peventarray), ::core::mem::transmute(pulfetched)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpEventSource2 {
type Vtable = ISpEventSource2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2373a435_6a4b_429e_a6ac_d4231a61975b);
}
impl ::core::convert::From<ISpEventSource2> for ::windows::core::IUnknown {
fn from(value: ISpEventSource2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpEventSource2> for ::windows::core::IUnknown {
fn from(value: &ISpEventSource2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpEventSource2> for ISpEventSource {
fn from(value: ISpEventSource2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpEventSource2> for ISpEventSource {
fn from(value: &ISpEventSource2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for &ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpEventSource2> for ISpNotifySource {
fn from(value: ISpEventSource2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpEventSource2> for ISpNotifySource {
fn from(value: &ISpEventSource2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for &ISpEventSource2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpEventSource2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotifysink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcount: u32, peventarray: *mut SPEVENTEX, pulfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpGrammarBuilder(pub ::windows::core::IUnknown);
impl ISpGrammarBuilder {
pub unsafe fn ResetGrammar(&self, newlanguage: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(newlanguage)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRule<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszrulename: Param0, dwruleid: u32, dwattributes: u32, fcreateifnotexist: Param3, phinitialstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszrulename.into_param().abi(), ::core::mem::transmute(dwruleid), ::core::mem::transmute(dwattributes), fcreateifnotexist.into_param().abi(), ::core::mem::transmute(phinitialstate)).ok()
}
pub unsafe fn ClearRule(&self, hstate: *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hstate)).ok()
}
pub unsafe fn CreateNewState(&self, hstate: *mut SPSTATEHANDLE__, phstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hstate), ::core::mem::transmute(phstate)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddWordTransition<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: Param2, pszseparators: Param3, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hfromstate), ::core::mem::transmute(htostate), psz.into_param().abi(), pszseparators.into_param().abi(), ::core::mem::transmute(ewordtype), ::core::mem::transmute(weight), ::core::mem::transmute(ppropinfo)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddRuleTransition(&self, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, hrule: *mut SPSTATEHANDLE__, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(hfromstate), ::core::mem::transmute(htostate), ::core::mem::transmute(hrule), ::core::mem::transmute(weight), ::core::mem::transmute(ppropinfo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddResource<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hrulestate: *mut SPSTATEHANDLE__, pszresourcename: Param1, pszresourcevalue: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrulestate), pszresourcename.into_param().abi(), pszresourcevalue.into_param().abi()).ok()
}
pub unsafe fn Commit(&self, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpGrammarBuilder {
type Vtable = ISpGrammarBuilder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8137828f_591a_4a42_be58_49ea7ebaac68);
}
impl ::core::convert::From<ISpGrammarBuilder> for ::windows::core::IUnknown {
fn from(value: ISpGrammarBuilder) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpGrammarBuilder> for ::windows::core::IUnknown {
fn from(value: &ISpGrammarBuilder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpGrammarBuilder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpGrammarBuilder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpGrammarBuilder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newlanguage: u16) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszrulename: super::super::Foundation::PWSTR, dwruleid: u32, dwattributes: u32, fcreateifnotexist: super::super::Foundation::BOOL, phinitialstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hstate: *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hstate: *mut SPSTATEHANDLE__, phstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: super::super::Foundation::PWSTR, pszseparators: super::super::Foundation::PWSTR, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const ::core::mem::ManuallyDrop<SPPROPERTYINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, hrule: *mut SPSTATEHANDLE__, weight: f32, ppropinfo: *const ::core::mem::ManuallyDrop<SPPROPERTYINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrulestate: *mut SPSTATEHANDLE__, pszresourcename: super::super::Foundation::PWSTR, pszresourcevalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpGrammarBuilder2(pub ::windows::core::IUnknown);
impl ISpGrammarBuilder2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddTextSubset<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: Param2, ematchmode: SPMATCHINGMODE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(hfromstate), ::core::mem::transmute(htostate), psz.into_param().abi(), ::core::mem::transmute(ematchmode)).ok()
}
pub unsafe fn SetPhoneticAlphabet(&self, phoneticalphabet: PHONETICALPHABET) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(phoneticalphabet)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpGrammarBuilder2 {
type Vtable = ISpGrammarBuilder2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8ab10026_20cc_4b20_8c22_a49c9ba78f60);
}
impl ::core::convert::From<ISpGrammarBuilder2> for ::windows::core::IUnknown {
fn from(value: ISpGrammarBuilder2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpGrammarBuilder2> for ::windows::core::IUnknown {
fn from(value: &ISpGrammarBuilder2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpGrammarBuilder2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpGrammarBuilder2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpGrammarBuilder2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: super::super::Foundation::PWSTR, ematchmode: SPMATCHINGMODE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phoneticalphabet: PHONETICALPHABET) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpLexicon(pub ::windows::core::IUnknown);
impl ISpLexicon {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPronunciations<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, dwflags: u32, pwordpronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(dwflags), ::core::mem::transmute(pwordpronunciationlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddPronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(epartofspeech), ::core::mem::transmute(pszpronunciation)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemovePronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(epartofspeech), ::core::mem::transmute(pszpronunciation)).ok()
}
pub unsafe fn GetGeneration(&self, pdwgeneration: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetGenerationChange(&self, dwflags: u32, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pwordlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWords(&self, dwflags: u32, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwflags), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pdwcookie), ::core::mem::transmute(pwordlist)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpLexicon {
type Vtable = ISpLexicon_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xda41a7c2_5383_4db2_916b_6c1719e3db58);
}
impl ::core::convert::From<ISpLexicon> for ::windows::core::IUnknown {
fn from(value: ISpLexicon) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpLexicon> for ::windows::core::IUnknown {
fn from(value: &ISpLexicon) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpLexicon_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, dwflags: u32, pwordpronunciationlist: *mut SPWORDPRONUNCIATIONLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, langid: u16, epartofspeech: SPPARTOFSPEECH, pszpronunciation: *const u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwflags: u32, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpMMSysAudio(pub ::windows::core::IUnknown);
impl ISpMMSysAudio {
pub unsafe fn Read(&self, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn Write(&self, pv: *const ::core::ffi::c_void, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Seek(&self, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dlibmove), ::core::mem::transmute(dworigin), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetSize(&self, libnewsize: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(libnewsize)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CopyTo<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstm: Param0, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstm.into_param().abi(), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread), ::core::mem::transmute(pcbwritten)).ok()
}
pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(grfcommitflags)).ok()
}
pub unsafe fn Revert(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn Stat(&self, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatstg), ::core::mem::transmute(grfstatflag)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Clone(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, pguidformatid: *const ::windows::core::GUID) -> ::windows::core::Result<*mut super::Audio::WAVEFORMATEX> {
let mut result__: <*mut super::Audio::WAVEFORMATEX as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidformatid), &mut result__).from_abi::<*mut super::Audio::WAVEFORMATEX>(result__)
}
pub unsafe fn SetState(&self, newstate: SPAUDIOSTATE, ullreserved: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(newstate), ::core::mem::transmute(ullreserved)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn SetFormat(&self, rguidfmtid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidfmtid), ::core::mem::transmute(pwaveformatex)).ok()
}
pub unsafe fn GetStatus(&self, pstatus: *mut SPAUDIOSTATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus)).ok()
}
pub unsafe fn SetBufferInfo(&self, pbuffinfo: *const SPAUDIOBUFFERINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbuffinfo)).ok()
}
pub unsafe fn GetBufferInfo(&self, pbuffinfo: *mut SPAUDIOBUFFERINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbuffinfo)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetDefaultFormat(&self, pformatid: *mut ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(pformatid), ::core::mem::transmute(ppcomemwaveformatex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)))
}
pub unsafe fn GetVolumeLevel(&self, plevel: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(plevel)).ok()
}
pub unsafe fn SetVolumeLevel(&self, level: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(level)).ok()
}
pub unsafe fn GetBufferNotifySize(&self, pcbsize: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcbsize)).ok()
}
pub unsafe fn SetBufferNotifySize(&self, cbsize: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(cbsize)).ok()
}
pub unsafe fn GetDeviceId(&self, pudeviceid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(pudeviceid)).ok()
}
pub unsafe fn SetDeviceId(&self, udeviceid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(udeviceid)).ok()
}
pub unsafe fn GetMMHandle(&self, phandle: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(phandle)).ok()
}
pub unsafe fn GetLineId(&self, pulineid: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(pulineid)).ok()
}
pub unsafe fn SetLineId(&self, ulineid: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulineid)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpMMSysAudio {
type Vtable = ISpMMSysAudio_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x15806f6e_1d70_4b48_98e6_3b1a007509ab);
}
impl ::core::convert::From<ISpMMSysAudio> for ::windows::core::IUnknown {
fn from(value: ISpMMSysAudio) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpMMSysAudio> for ::windows::core::IUnknown {
fn from(value: &ISpMMSysAudio) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpMMSysAudio> for ISpAudio {
fn from(value: ISpMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpMMSysAudio> for ISpAudio {
fn from(value: &ISpMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpAudio> for ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpAudio> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpAudio> for &ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpAudio> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpMMSysAudio> for ISpStreamFormat {
fn from(value: ISpMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpMMSysAudio> for ISpStreamFormat {
fn from(value: &ISpMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for &ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpMMSysAudio> for super::super::System::Com::IStream {
fn from(value: ISpMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpMMSysAudio> for super::super::System::Com::IStream {
fn from(value: &ISpMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for &ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpMMSysAudio> for super::super::System::Com::ISequentialStream {
fn from(value: ISpMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpMMSysAudio> for super::super::System::Com::ISequentialStream {
fn from(value: &ISpMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for &ISpMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpMMSysAudio_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *const ::core::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK, plibnewposition: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, libnewsize: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstm: ::windows::core::RawPtr, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grfcommitflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstm: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidformatid: *const ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newstate: SPAUDIOSTATE, ullreserved: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidfmtid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut SPAUDIOSTATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffinfo: *const SPAUDIOBUFFERINFO) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbuffinfo: *mut SPAUDIOBUFFERINFO) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pformatid: *mut ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plevel: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, level: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcbsize: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, cbsize: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pudeviceid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, udeviceid: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phandle: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulineid: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulineid: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpNotifyCallback(pub ::windows::core::IUnknown);
impl ISpNotifyCallback {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn NotifyCallback<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, wparam: Param0, lparam: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpNotifyCallback {
type Vtable = ISpNotifyCallback_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::zeroed();
}
impl ::core::convert::From<ISpNotifyCallback> for ::windows::core::IUnknown {
fn from(value: ISpNotifyCallback) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpNotifyCallback> for ::windows::core::IUnknown {
fn from(value: &ISpNotifyCallback) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpNotifyCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpNotifyCallback {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpNotifyCallback_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpNotifySink(pub ::windows::core::IUnknown);
impl ISpNotifySink {
pub unsafe fn Notify(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpNotifySink {
type Vtable = ISpNotifySink_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x259684dc_37c3_11d2_9603_00c04f8ee628);
}
impl ::core::convert::From<ISpNotifySink> for ::windows::core::IUnknown {
fn from(value: ISpNotifySink) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpNotifySink> for ::windows::core::IUnknown {
fn from(value: &ISpNotifySink) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpNotifySink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpNotifySink {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpNotifySink_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpNotifySource(pub ::windows::core::IUnknown);
impl ISpNotifySource {
pub unsafe fn SetNotifySink<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifySink>>(&self, pnotifysink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotifysink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackInterface<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
pub unsafe fn SetNotifyWin32Event(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WaitForNotifyEvent(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNotifyEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for ISpNotifySource {
type Vtable = ISpNotifySource_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5eff4aef_8487_11d2_961c_00c04f8ee628);
}
impl ::core::convert::From<ISpNotifySource> for ::windows::core::IUnknown {
fn from(value: ISpNotifySource) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpNotifySource> for ::windows::core::IUnknown {
fn from(value: &ISpNotifySource) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpNotifySource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpNotifySource {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpNotifySource_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotifysink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpNotifyTranslator(pub ::windows::core::IUnknown);
impl ISpNotifyTranslator {
pub unsafe fn Notify(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InitWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InitCallback<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InitSpNotifyCallback<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InitWin32Event<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HANDLE>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hevent: Param0, fclosehandleonrelease: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), hevent.into_param().abi(), fclosehandleonrelease.into_param().abi()).ok()
}
pub unsafe fn Wait(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
}
unsafe impl ::windows::core::Interface for ISpNotifyTranslator {
type Vtable = ISpNotifyTranslator_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaca16614_5d3d_11d2_960e_00c04f8ee628);
}
impl ::core::convert::From<ISpNotifyTranslator> for ::windows::core::IUnknown {
fn from(value: ISpNotifyTranslator) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpNotifyTranslator> for ::windows::core::IUnknown {
fn from(value: &ISpNotifyTranslator) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpNotifyTranslator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpNotifyTranslator {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpNotifyTranslator> for ISpNotifySink {
fn from(value: ISpNotifyTranslator) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpNotifyTranslator> for ISpNotifySink {
fn from(value: &ISpNotifyTranslator) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySink> for ISpNotifyTranslator {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySink> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySink> for &ISpNotifyTranslator {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySink> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpNotifyTranslator_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hevent: super::super::Foundation::HANDLE, fclosehandleonrelease: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpObjectToken(pub ::windows::core::IUnknown);
impl ISpObjectToken {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, cbdata: u32, pdata: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(cbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), pszvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, dwvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(dwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pdwvalue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pdwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkeyname: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pszsubkeyname.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszcategoryid: Param0, psztokenid: Param1, fcreateifnotexist: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pszcategoryid.into_param().abi(), psztokenid.into_param().abi(), fcreateifnotexist.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetCategory(&self) -> ::windows::core::Result<ISpObjectTokenCategory> {
let mut result__: <ISpObjectTokenCategory as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectTokenCategory>(result__)
}
pub unsafe fn CreateInstance<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkouter: Param0, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStorageFileName<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, clsidcaller: *const ::windows::core::GUID, pszvaluename: Param1, pszfilenamespecifier: Param2, nfolder: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidcaller), pszvaluename.into_param().abi(), pszfilenamespecifier.into_param().abi(), ::core::mem::transmute(nfolder), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveStorageFileName<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, clsidcaller: *const ::windows::core::GUID, pszkeyname: Param1, fdeletefile: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidcaller), pszkeyname.into_param().abi(), fdeletefile.into_param().abi()).ok()
}
pub unsafe fn Remove(&self, pclsidcaller: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(pclsidcaller)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, psztypeofui: Param0, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: Param3, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), punkobject.into_param().abi(), ::core::mem::transmute(pfsupported)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisplayUI<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hwndparent: Param0, psztitle: Param1, psztypeofui: Param2, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), hwndparent.into_param().abi(), psztitle.into_param().abi(), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), punkobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn MatchesAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszattributes: Param0, pfmatches: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pszattributes.into_param().abi(), ::core::mem::transmute(pfmatches)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpObjectToken {
type Vtable = ISpObjectToken_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x14056589_e16c_11d2_bb90_00c04f8ee6c0);
}
impl ::core::convert::From<ISpObjectToken> for ::windows::core::IUnknown {
fn from(value: ISpObjectToken) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpObjectToken> for ::windows::core::IUnknown {
fn from(value: &ISpObjectToken) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpObjectToken> for ISpDataKey {
fn from(value: ISpObjectToken) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpObjectToken> for ISpDataKey {
fn from(value: &ISpObjectToken) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for ISpObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for &ISpObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpObjectToken_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, cbdata: u32, pdata: *const u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, ppszvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, dwvalue: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkeyname: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszsubkeyname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszvaluename: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcategoryid: super::super::Foundation::PWSTR, psztokenid: super::super::Foundation::PWSTR, fcreateifnotexist: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemtokenid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptokencategory: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidcaller: *const ::windows::core::GUID, pszvaluename: super::super::Foundation::PWSTR, pszfilenamespecifier: super::super::Foundation::PWSTR, nfolder: u32, ppszfilepath: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidcaller: *const ::windows::core::GUID, pszkeyname: super::super::Foundation::PWSTR, fdeletefile: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsidcaller: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: ::windows::core::RawPtr, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: super::super::Foundation::HWND, psztitle: super::super::Foundation::PWSTR, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszattributes: super::super::Foundation::PWSTR, pfmatches: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpObjectTokenCategory(pub ::windows::core::IUnknown);
impl ISpObjectTokenCategory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, cbdata: u32, pdata: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(cbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), pszvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, dwvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(dwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pdwvalue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pdwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkeyname: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pszsubkeyname.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszcategoryid: Param0, fcreateifnotexist: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pszcategoryid.into_param().abi(), fcreateifnotexist.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetDataKey(&self, spdkl: SPDATAKEYLOCATION) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(spdkl), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumTokens<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pzsreqattribs: Param0, pszoptattribs: Param1) -> ::windows::core::Result<IEnumSpObjectTokens> {
let mut result__: <IEnumSpObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), pzsreqattribs.into_param().abi(), pszoptattribs.into_param().abi(), &mut result__).from_abi::<IEnumSpObjectTokens>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDefaultTokenId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, psztokenid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), psztokenid.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDefaultTokenId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpObjectTokenCategory {
type Vtable = ISpObjectTokenCategory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d3d3845_39af_4850_bbf9_40b49780011d);
}
impl ::core::convert::From<ISpObjectTokenCategory> for ::windows::core::IUnknown {
fn from(value: ISpObjectTokenCategory) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpObjectTokenCategory> for ::windows::core::IUnknown {
fn from(value: &ISpObjectTokenCategory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpObjectTokenCategory> for ISpDataKey {
fn from(value: ISpObjectTokenCategory) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpObjectTokenCategory> for ISpDataKey {
fn from(value: &ISpObjectTokenCategory) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for ISpObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for &ISpObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpObjectTokenCategory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, cbdata: u32, pdata: *const u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, ppszvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, dwvalue: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkeyname: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszsubkeyname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszvaluename: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcategoryid: super::super::Foundation::PWSTR, fcreateifnotexist: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemcategoryid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, spdkl: SPDATAKEYLOCATION, ppdatakey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pzsreqattribs: super::super::Foundation::PWSTR, pszoptattribs: super::super::Foundation::PWSTR, ppenum: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztokenid: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemtokenid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpObjectTokenInit(pub ::windows::core::IUnknown);
impl ISpObjectTokenInit {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, cbdata: u32, pdata: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(cbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), pszvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, dwvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(dwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pdwvalue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pdwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkeyname: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pszsubkeyname.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszcategoryid: Param0, psztokenid: Param1, fcreateifnotexist: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pszcategoryid.into_param().abi(), psztokenid.into_param().abi(), fcreateifnotexist.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetId(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetCategory(&self) -> ::windows::core::Result<ISpObjectTokenCategory> {
let mut result__: <ISpObjectTokenCategory as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectTokenCategory>(result__)
}
pub unsafe fn CreateInstance<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkouter: Param0, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), punkouter.into_param().abi(), ::core::mem::transmute(dwclscontext), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStorageFileName<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, clsidcaller: *const ::windows::core::GUID, pszvaluename: Param1, pszfilenamespecifier: Param2, nfolder: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidcaller), pszvaluename.into_param().abi(), pszfilenamespecifier.into_param().abi(), ::core::mem::transmute(nfolder), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveStorageFileName<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, clsidcaller: *const ::windows::core::GUID, pszkeyname: Param1, fdeletefile: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(clsidcaller), pszkeyname.into_param().abi(), fdeletefile.into_param().abi()).ok()
}
pub unsafe fn Remove(&self, pclsidcaller: *const ::windows::core::GUID) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(pclsidcaller)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, psztypeofui: Param0, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: Param3, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), punkobject.into_param().abi(), ::core::mem::transmute(pfsupported)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisplayUI<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param5: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hwndparent: Param0, psztitle: Param1, psztypeofui: Param2, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: Param5) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), hwndparent.into_param().abi(), psztitle.into_param().abi(), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), punkobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn MatchesAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszattributes: Param0, pfmatches: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), pszattributes.into_param().abi(), ::core::mem::transmute(pfmatches)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn InitFromDataKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, ISpDataKey>>(&self, pszcategoryid: Param0, psztokenid: Param1, pdatakey: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pszcategoryid.into_param().abi(), psztokenid.into_param().abi(), pdatakey.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpObjectTokenInit {
type Vtable = ISpObjectTokenInit_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb8aab0cf_346f_49d8_9499_c8b03f161d51);
}
impl ::core::convert::From<ISpObjectTokenInit> for ::windows::core::IUnknown {
fn from(value: ISpObjectTokenInit) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpObjectTokenInit> for ::windows::core::IUnknown {
fn from(value: &ISpObjectTokenInit) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpObjectTokenInit> for ISpObjectToken {
fn from(value: ISpObjectTokenInit) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpObjectTokenInit> for ISpObjectToken {
fn from(value: &ISpObjectTokenInit) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpObjectToken> for ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ISpObjectToken> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpObjectToken> for &ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ISpObjectToken> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpObjectTokenInit> for ISpDataKey {
fn from(value: ISpObjectTokenInit) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpObjectTokenInit> for ISpDataKey {
fn from(value: &ISpObjectTokenInit) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for &ISpObjectTokenInit {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpObjectTokenInit_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, cbdata: u32, pdata: *const u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, ppszvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, dwvalue: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkeyname: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszsubkeyname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszvaluename: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcategoryid: super::super::Foundation::PWSTR, psztokenid: super::super::Foundation::PWSTR, fcreateifnotexist: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemtokenid: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptokencategory: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkouter: ::windows::core::RawPtr, dwclscontext: u32, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidcaller: *const ::windows::core::GUID, pszvaluename: super::super::Foundation::PWSTR, pszfilenamespecifier: super::super::Foundation::PWSTR, nfolder: u32, ppszfilepath: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidcaller: *const ::windows::core::GUID, pszkeyname: super::super::Foundation::PWSTR, fdeletefile: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pclsidcaller: *const ::windows::core::GUID) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: ::windows::core::RawPtr, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: super::super::Foundation::HWND, psztitle: super::super::Foundation::PWSTR, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, punkobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszattributes: super::super::Foundation::PWSTR, pfmatches: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszcategoryid: super::super::Foundation::PWSTR, psztokenid: super::super::Foundation::PWSTR, pdatakey: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpObjectWithToken(pub ::windows::core::IUnknown);
impl ISpObjectWithToken {
pub unsafe fn SetObjectToken<'a, Param0: ::windows::core::IntoParam<'a, ISpObjectToken>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
pub unsafe fn GetObjectToken(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpObjectWithToken {
type Vtable = ISpObjectWithToken_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b559f40_e952_11d2_bb91_00c04f8ee6c0);
}
impl ::core::convert::From<ISpObjectWithToken> for ::windows::core::IUnknown {
fn from(value: ISpObjectWithToken) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpObjectWithToken> for ::windows::core::IUnknown {
fn from(value: &ISpObjectWithToken) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpObjectWithToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpObjectWithToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpObjectWithToken_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhoneConverter(pub ::windows::core::IUnknown);
impl ISpPhoneConverter {
pub unsafe fn SetObjectToken<'a, Param0: ::windows::core::IntoParam<'a, ISpObjectToken>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
pub unsafe fn GetObjectToken(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PhoneToId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszphone: Param0) -> ::windows::core::Result<u16> {
let mut result__: <u16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszphone.into_param().abi(), &mut result__).from_abi::<u16>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IdToPhone(&self, pid: *const u16, pszphone: super::super::Foundation::PWSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pid), ::core::mem::transmute(pszphone)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpPhoneConverter {
type Vtable = ISpPhoneConverter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8445c581_0cac_4a38_abfe_9b2ce2826455);
}
impl ::core::convert::From<ISpPhoneConverter> for ::windows::core::IUnknown {
fn from(value: ISpPhoneConverter) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhoneConverter> for ::windows::core::IUnknown {
fn from(value: &ISpPhoneConverter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpPhoneConverter> for ISpObjectWithToken {
fn from(value: ISpPhoneConverter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpPhoneConverter> for ISpObjectWithToken {
fn from(value: &ISpPhoneConverter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpObjectWithToken> for ISpPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ISpObjectWithToken> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpObjectWithToken> for &ISpPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ISpObjectWithToken> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhoneConverter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszphone: super::super::Foundation::PWSTR, pid: *mut u16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pid: *const u16, pszphone: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhoneticAlphabetConverter(pub ::windows::core::IUnknown);
impl ISpPhoneticAlphabetConverter {
pub unsafe fn GetLangId(&self) -> ::windows::core::Result<u16> {
let mut result__: <u16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u16>(result__)
}
pub unsafe fn SetLangId(&self, langid: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(langid)).ok()
}
pub unsafe fn SAPI2UPS(&self, pszsapiid: *const u16, pszupsid: *mut u16, cmaxlength: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszsapiid), ::core::mem::transmute(pszupsid), ::core::mem::transmute(cmaxlength)).ok()
}
pub unsafe fn UPS2SAPI(&self, pszupsid: *const u16, pszsapiid: *mut u16, cmaxlength: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(pszupsid), ::core::mem::transmute(pszsapiid), ::core::mem::transmute(cmaxlength)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetMaxConvertLength<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, csrclength: u32, bsapi2ups: Param1) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(csrclength), bsapi2ups.into_param().abi(), &mut result__).from_abi::<u32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpPhoneticAlphabetConverter {
type Vtable = ISpPhoneticAlphabetConverter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x133adcd4_19b4_4020_9fdc_842e78253b17);
}
impl ::core::convert::From<ISpPhoneticAlphabetConverter> for ::windows::core::IUnknown {
fn from(value: ISpPhoneticAlphabetConverter) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhoneticAlphabetConverter> for ::windows::core::IUnknown {
fn from(value: &ISpPhoneticAlphabetConverter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhoneticAlphabetConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhoneticAlphabetConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhoneticAlphabetConverter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, plangid: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, langid: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsapiid: *const u16, pszupsid: *mut u16, cmaxlength: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszupsid: *const u16, pszsapiid: *mut u16, cmaxlength: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, csrclength: u32, bsapi2ups: super::super::Foundation::BOOL, pcmaxdestlength: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhoneticAlphabetSelection(pub ::windows::core::IUnknown);
impl ISpPhoneticAlphabetSelection {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsAlphabetUPS(&self) -> ::windows::core::Result<super::super::Foundation::BOOL> {
let mut result__: <super::super::Foundation::BOOL as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BOOL>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAlphabetToUPS<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fforceups: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), fforceups.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpPhoneticAlphabetSelection {
type Vtable = ISpPhoneticAlphabetSelection_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb2745efd_42ce_48ca_81f1_a96e02538a90);
}
impl ::core::convert::From<ISpPhoneticAlphabetSelection> for ::windows::core::IUnknown {
fn from(value: ISpPhoneticAlphabetSelection) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhoneticAlphabetSelection> for ::windows::core::IUnknown {
fn from(value: &ISpPhoneticAlphabetSelection) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhoneticAlphabetSelection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhoneticAlphabetSelection {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhoneticAlphabetSelection_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfisups: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fforceups: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhrase(pub ::windows::core::IUnknown);
impl ISpPhrase {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpPhrase {
type Vtable = ISpPhrase_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1a5c0354_b621_4b5a_8791_d306ed379e53);
}
impl ::core::convert::From<ISpPhrase> for ::windows::core::IUnknown {
fn from(value: ISpPhrase) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhrase> for ::windows::core::IUnknown {
fn from(value: &ISpPhrase) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhrase {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhrase {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhrase_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhrase2(pub ::windows::core::IUnknown);
impl ISpPhrase2 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLResult(&self, ppszcomemxmlresult: *mut super::super::Foundation::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppszcomemxmlresult), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLErrorInfo(&self, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(psemanticerrorinfo)).ok()
}
pub unsafe fn GetAudio(&self, ulstartelement: u32, celements: u32) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpPhrase2 {
type Vtable = ISpPhrase2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf264da52_e457_4696_b856_a737b717af79);
}
impl ::core::convert::From<ISpPhrase2> for ::windows::core::IUnknown {
fn from(value: ISpPhrase2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhrase2> for ::windows::core::IUnknown {
fn from(value: &ISpPhrase2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhrase2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhrase2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpPhrase2> for ISpPhrase {
fn from(value: ISpPhrase2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpPhrase2> for ISpPhrase {
fn from(value: &ISpPhrase2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for ISpPhrase2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for &ISpPhrase2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhrase2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemxmlresult: *mut super::super::Foundation::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpPhraseAlt(pub ::windows::core::IUnknown);
impl ISpPhraseAlt {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
pub unsafe fn GetAltInfo(&self, ppparent: *mut ::core::option::Option<ISpPhrase>, pulstartelementinparent: *mut u32, pcelementsinparent: *mut u32, pcelementsinalt: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppparent), ::core::mem::transmute(pulstartelementinparent), ::core::mem::transmute(pcelementsinparent), ::core::mem::transmute(pcelementsinalt)).ok()
}
pub unsafe fn Commit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpPhraseAlt {
type Vtable = ISpPhraseAlt_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8fcebc98_4e49_4067_9c6c_d86a0e092e3d);
}
impl ::core::convert::From<ISpPhraseAlt> for ::windows::core::IUnknown {
fn from(value: ISpPhraseAlt) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpPhraseAlt> for ::windows::core::IUnknown {
fn from(value: &ISpPhraseAlt) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpPhraseAlt {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpPhraseAlt {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpPhraseAlt> for ISpPhrase {
fn from(value: ISpPhraseAlt) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpPhraseAlt> for ISpPhrase {
fn from(value: &ISpPhraseAlt) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for ISpPhraseAlt {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for &ISpPhraseAlt {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpPhraseAlt_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppparent: *mut ::windows::core::RawPtr, pulstartelementinparent: *mut u32, pcelementsinparent: *mut u32, pcelementsinalt: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpProperties(pub ::windows::core::IUnknown);
impl ISpProperties {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyNum<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, lvalue: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pname.into_param().abi(), ::core::mem::transmute(lvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyNum<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, plvalue: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pname.into_param().abi(), ::core::mem::transmute(plvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, pvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pname.into_param().abi(), pvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pname.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpProperties {
type Vtable = ISpProperties_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5b4fb971_b115_4de1_ad97_e482e3bf6ee4);
}
impl ::core::convert::From<ISpProperties> for ::windows::core::IUnknown {
fn from(value: ISpProperties) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpProperties> for ::windows::core::IUnknown {
fn from(value: &ISpProperties) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpProperties {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpProperties {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpProperties_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, lvalue: i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, plvalue: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, pvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, ppcomemvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoContext(pub ::windows::core::IUnknown);
impl ISpRecoContext {
pub unsafe fn SetNotifySink<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifySink>>(&self, pnotifysink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotifysink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackInterface<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
pub unsafe fn SetNotifyWin32Event(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WaitForNotifyEvent(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNotifyEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetInterest(&self, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulleventinterest), ::core::mem::transmute(ullqueuedinterest)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEvents(&self, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcount), ::core::mem::transmute(peventarray), ::core::mem::transmute(pulfetched)).ok()
}
pub unsafe fn GetInfo(&self, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinfo)).ok()
}
pub unsafe fn GetRecognizer(&self) -> ::windows::core::Result<ISpRecognizer> {
let mut result__: <ISpRecognizer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecognizer>(result__)
}
pub unsafe fn CreateGrammar(&self, ullgrammarid: u64) -> ::windows::core::Result<ISpRecoGrammar> {
let mut result__: <ISpRecoGrammar as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(ullgrammarid), &mut result__).from_abi::<ISpRecoGrammar>(result__)
}
pub unsafe fn GetStatus(&self, pstatus: *mut SPRECOCONTEXTSTATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus)).ok()
}
pub unsafe fn GetMaxAlternates(&self, pcalternates: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(pcalternates)).ok()
}
pub unsafe fn SetMaxAlternates(&self, calternates: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(calternates)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn SetAudioOptions(&self, options: SPAUDIOOPTIONS, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(options), ::core::mem::transmute(paudioformatid), ::core::mem::transmute(pwaveformatex)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetAudioOptions(&self, poptions: *mut SPAUDIOOPTIONS, paudioformatid: *mut ::windows::core::GUID, ppcomemwfex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(poptions), ::core::mem::transmute(paudioformatid), ::core::mem::transmute(ppcomemwfex)).ok()
}
pub unsafe fn DeserializeResult(&self, pserializedresult: *const SPSERIALIZEDRESULT) -> ::windows::core::Result<ISpRecoResult> {
let mut result__: <ISpRecoResult as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(pserializedresult), &mut result__).from_abi::<ISpRecoResult>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Bookmark<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, options: SPBOOKMARKOPTIONS, ullstreamposition: u64, lparamevent: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(options), ::core::mem::transmute(ullstreamposition), lparamevent.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAdaptationData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, padaptationdata: Param0, cch: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), padaptationdata.into_param().abi(), ::core::mem::transmute(cch)).ok()
}
pub unsafe fn Pause(&self, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved)).ok()
}
pub unsafe fn Resume(&self, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetVoice<'a, Param0: ::windows::core::IntoParam<'a, ISpVoice>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pvoice: Param0, fallowformatchanges: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pvoice.into_param().abi(), fallowformatchanges.into_param().abi()).ok()
}
pub unsafe fn GetVoice(&self) -> ::windows::core::Result<ISpVoice> {
let mut result__: <ISpVoice as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpVoice>(result__)
}
pub unsafe fn SetVoicePurgeEvent(&self, ulleventinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulleventinterest)).ok()
}
pub unsafe fn GetVoicePurgeEvent(&self, pulleventinterest: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(pulleventinterest)).ok()
}
pub unsafe fn SetContextState(&self, econtextstate: SPCONTEXTSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(econtextstate)).ok()
}
pub unsafe fn GetContextState(&self, pecontextstate: *mut SPCONTEXTSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(pecontextstate)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecoContext {
type Vtable = ISpRecoContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xf740a62f_7c15_489e_8234_940a33d9272d);
}
impl ::core::convert::From<ISpRecoContext> for ::windows::core::IUnknown {
fn from(value: ISpRecoContext) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoContext> for ::windows::core::IUnknown {
fn from(value: &ISpRecoContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRecoContext> for ISpEventSource {
fn from(value: ISpRecoContext) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoContext> for ISpEventSource {
fn from(value: &ISpRecoContext) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for &ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpRecoContext> for ISpNotifySource {
fn from(value: ISpRecoContext) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoContext> for ISpNotifySource {
fn from(value: &ISpRecoContext) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for &ISpRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotifysink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecognizer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ullgrammarid: u64, ppgrammar: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut SPRECOCONTEXTSTATUS) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcalternates: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, calternates: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: SPAUDIOOPTIONS, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, poptions: *mut SPAUDIOOPTIONS, paudioformatid: *mut ::windows::core::GUID, ppcomemwfex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pserializedresult: *const SPSERIALIZEDRESULT, ppresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: SPBOOKMARKOPTIONS, ullstreamposition: u64, lparamevent: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, padaptationdata: super::super::Foundation::PWSTR, cch: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pvoice: ::windows::core::RawPtr, fallowformatchanges: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppvoice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulleventinterest: u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pulleventinterest: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, econtextstate: SPCONTEXTSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pecontextstate: *mut SPCONTEXTSTATE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoContext2(pub ::windows::core::IUnknown);
impl ISpRecoContext2 {
pub unsafe fn SetGrammarOptions(&self, egrammaroptions: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(egrammaroptions)).ok()
}
pub unsafe fn GetGrammarOptions(&self, pegrammaroptions: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pegrammaroptions)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAdaptationData2<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, padaptationdata: Param0, cch: u32, ptopicname: Param2, eadaptationsettings: u32, erelevance: SPADAPTATIONRELEVANCE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), padaptationdata.into_param().abi(), ::core::mem::transmute(cch), ptopicname.into_param().abi(), ::core::mem::transmute(eadaptationsettings), ::core::mem::transmute(erelevance)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecoContext2 {
type Vtable = ISpRecoContext2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbead311c_52ff_437f_9464_6b21054ca73d);
}
impl ::core::convert::From<ISpRecoContext2> for ::windows::core::IUnknown {
fn from(value: ISpRecoContext2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoContext2> for ::windows::core::IUnknown {
fn from(value: &ISpRecoContext2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoContext2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoContext2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoContext2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, egrammaroptions: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pegrammaroptions: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, padaptationdata: super::super::Foundation::PWSTR, cch: u32, ptopicname: super::super::Foundation::PWSTR, eadaptationsettings: u32, erelevance: SPADAPTATIONRELEVANCE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoGrammar(pub ::windows::core::IUnknown);
impl ISpRecoGrammar {
pub unsafe fn ResetGrammar(&self, newlanguage: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(newlanguage)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRule<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszrulename: Param0, dwruleid: u32, dwattributes: u32, fcreateifnotexist: Param3, phinitialstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszrulename.into_param().abi(), ::core::mem::transmute(dwruleid), ::core::mem::transmute(dwattributes), fcreateifnotexist.into_param().abi(), ::core::mem::transmute(phinitialstate)).ok()
}
pub unsafe fn ClearRule(&self, hstate: *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(hstate)).ok()
}
pub unsafe fn CreateNewState(&self, hstate: *mut SPSTATEHANDLE__, phstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(hstate), ::core::mem::transmute(phstate)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddWordTransition<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: Param2, pszseparators: Param3, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(hfromstate), ::core::mem::transmute(htostate), psz.into_param().abi(), pszseparators.into_param().abi(), ::core::mem::transmute(ewordtype), ::core::mem::transmute(weight), ::core::mem::transmute(ppropinfo)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddRuleTransition(&self, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, hrule: *mut SPSTATEHANDLE__, weight: f32, ppropinfo: *const SPPROPERTYINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(hfromstate), ::core::mem::transmute(htostate), ::core::mem::transmute(hrule), ::core::mem::transmute(weight), ::core::mem::transmute(ppropinfo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddResource<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hrulestate: *mut SPSTATEHANDLE__, pszresourcename: Param1, pszresourcevalue: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(hrulestate), pszresourcename.into_param().abi(), pszresourcevalue.into_param().abi()).ok()
}
pub unsafe fn Commit(&self, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwreserved)).ok()
}
pub unsafe fn GetGrammarId(&self, pullgrammarid: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(pullgrammarid)).ok()
}
pub unsafe fn GetRecoContext(&self) -> ::windows::core::Result<ISpRecoContext> {
let mut result__: <ISpRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecoContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszfilename: Param0, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), pszfilename.into_param().abi(), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromObject<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, rcid: *const ::windows::core::GUID, pszgrammarname: Param1, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(rcid), pszgrammarname.into_param().abi(), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HINSTANCE>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hmodule: Param0, pszresourcename: Param1, pszresourcetype: Param2, wlanguage: u16, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), hmodule.into_param().abi(), pszresourcename.into_param().abi(), pszresourcetype.into_param().abi(), ::core::mem::transmute(wlanguage), ::core::mem::transmute(options)).ok()
}
pub unsafe fn LoadCmdFromMemory(&self, pgrammar: *const SPBINARYGRAMMAR, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(pgrammar), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromProprietaryGrammar<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, rguidparam: *const ::windows::core::GUID, pszstringparam: Param1, pvdataprarm: *const ::core::ffi::c_void, cbdatasize: u32, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidparam), pszstringparam.into_param().abi(), ::core::mem::transmute(pvdataprarm), ::core::mem::transmute(cbdatasize), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRuleState<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszname: Param0, preserved: *mut ::core::ffi::c_void, newstate: SPRULESTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), pszname.into_param().abi(), ::core::mem::transmute(preserved), ::core::mem::transmute(newstate)).ok()
}
pub unsafe fn SetRuleIdState(&self, ulruleid: u32, newstate: SPRULESTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulruleid), ::core::mem::transmute(newstate)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadDictation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, psztopicname: Param0, options: SPLOADOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), psztopicname.into_param().abi(), ::core::mem::transmute(options)).ok()
}
pub unsafe fn UnloadDictation(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetDictationState(&self, newstate: SPRULESTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(newstate)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetWordSequenceData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, ptext: Param0, cchtext: u32, pinfo: *const SPTEXTSELECTIONINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ptext.into_param().abi(), ::core::mem::transmute(cchtext), ::core::mem::transmute(pinfo)).ok()
}
pub unsafe fn SetTextSelection(&self, pinfo: *const SPTEXTSELECTIONINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinfo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPronounceable<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszword: Param0, pwordpronounceable: *mut SPWORDPRONOUNCEABLE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), pszword.into_param().abi(), ::core::mem::transmute(pwordpronounceable)).ok()
}
pub unsafe fn SetGrammarState(&self, egrammarstate: SPGRAMMARSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(egrammarstate)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn SaveCmd<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstream: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), pstream.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn GetGrammarState(&self, pegrammarstate: *mut SPGRAMMARSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(pegrammarstate)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecoGrammar {
type Vtable = ISpRecoGrammar_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2177db29_7f45_47d0_8554_067e91c80502);
}
impl ::core::convert::From<ISpRecoGrammar> for ::windows::core::IUnknown {
fn from(value: ISpRecoGrammar) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoGrammar> for ::windows::core::IUnknown {
fn from(value: &ISpRecoGrammar) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRecoGrammar> for ISpGrammarBuilder {
fn from(value: ISpRecoGrammar) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoGrammar> for ISpGrammarBuilder {
fn from(value: &ISpRecoGrammar) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpGrammarBuilder> for ISpRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ISpGrammarBuilder> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpGrammarBuilder> for &ISpRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ISpGrammarBuilder> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoGrammar_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newlanguage: u16) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszrulename: super::super::Foundation::PWSTR, dwruleid: u32, dwattributes: u32, fcreateifnotexist: super::super::Foundation::BOOL, phinitialstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hstate: *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hstate: *mut SPSTATEHANDLE__, phstate: *mut *mut SPSTATEHANDLE__) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, psz: super::super::Foundation::PWSTR, pszseparators: super::super::Foundation::PWSTR, ewordtype: SPGRAMMARWORDTYPE, weight: f32, ppropinfo: *const ::core::mem::ManuallyDrop<SPPROPERTYINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hfromstate: *mut SPSTATEHANDLE__, htostate: *mut SPSTATEHANDLE__, hrule: *mut SPSTATEHANDLE__, weight: f32, ppropinfo: *const ::core::mem::ManuallyDrop<SPPROPERTYINFO>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hrulestate: *mut SPSTATEHANDLE__, pszresourcename: super::super::Foundation::PWSTR, pszresourcevalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwreserved: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pullgrammarid: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecoctxt: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszfilename: super::super::Foundation::PWSTR, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rcid: *const ::windows::core::GUID, pszgrammarname: super::super::Foundation::PWSTR, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hmodule: super::super::Foundation::HINSTANCE, pszresourcename: super::super::Foundation::PWSTR, pszresourcetype: super::super::Foundation::PWSTR, wlanguage: u16, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pgrammar: *const SPBINARYGRAMMAR, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidparam: *const ::windows::core::GUID, pszstringparam: super::super::Foundation::PWSTR, pvdataprarm: *const ::core::ffi::c_void, cbdatasize: u32, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszname: super::super::Foundation::PWSTR, preserved: *mut ::core::ffi::c_void, newstate: SPRULESTATE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulruleid: u32, newstate: SPRULESTATE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztopicname: super::super::Foundation::PWSTR, options: SPLOADOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newstate: SPRULESTATE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptext: super::super::Foundation::PWSTR, cchtext: u32, pinfo: *const SPTEXTSELECTIONINFO) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinfo: *const SPTEXTSELECTIONINFO) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszword: super::super::Foundation::PWSTR, pwordpronounceable: *mut SPWORDPRONOUNCEABLE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, egrammarstate: SPGRAMMARSTATE) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, ppszcomemerrortext: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pegrammarstate: *mut SPGRAMMARSTATE) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoGrammar2(pub ::windows::core::IUnknown);
impl ISpRecoGrammar2 {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRules(&self, ppcomemrules: *mut *mut SPRULE, punumrules: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppcomemrules), ::core::mem::transmute(punumrules)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromFile2<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszfilename: Param0, options: SPLOADOPTIONS, pszsharinguri: Param2, pszbaseuri: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszfilename.into_param().abi(), ::core::mem::transmute(options), pszsharinguri.into_param().abi(), pszbaseuri.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadCmdFromMemory2<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pgrammar: *const SPBINARYGRAMMAR, options: SPLOADOPTIONS, pszsharinguri: Param2, pszbaseuri: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pgrammar), ::core::mem::transmute(options), pszsharinguri.into_param().abi(), pszbaseuri.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRulePriority<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszrulename: Param0, ulruleid: u32, nrulepriority: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszrulename.into_param().abi(), ::core::mem::transmute(ulruleid), ::core::mem::transmute(nrulepriority)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetRuleWeight<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszrulename: Param0, ulruleid: u32, flweight: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszrulename.into_param().abi(), ::core::mem::transmute(ulruleid), ::core::mem::transmute(flweight)).ok()
}
pub unsafe fn SetDictationWeight(&self, flweight: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(flweight)).ok()
}
pub unsafe fn SetGrammarLoader<'a, Param0: ::windows::core::IntoParam<'a, ISpeechResourceLoader>>(&self, ploader: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ploader.into_param().abi()).ok()
}
#[cfg(feature = "Win32_System_Com_Urlmon")]
pub unsafe fn SetSMLSecurityManager<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::Urlmon::IInternetSecurityManager>>(&self, psmlsecuritymanager: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), psmlsecuritymanager.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecoGrammar2 {
type Vtable = ISpRecoGrammar2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4b37bc9e_9ed6_44a3_93d3_18f022b79ec3);
}
impl ::core::convert::From<ISpRecoGrammar2> for ::windows::core::IUnknown {
fn from(value: ISpRecoGrammar2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoGrammar2> for ::windows::core::IUnknown {
fn from(value: &ISpRecoGrammar2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoGrammar2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoGrammar2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoGrammar2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemrules: *mut *mut SPRULE, punumrules: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszfilename: super::super::Foundation::PWSTR, options: SPLOADOPTIONS, pszsharinguri: super::super::Foundation::PWSTR, pszbaseuri: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pgrammar: *const SPBINARYGRAMMAR, options: SPLOADOPTIONS, pszsharinguri: super::super::Foundation::PWSTR, pszbaseuri: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszrulename: super::super::Foundation::PWSTR, ulruleid: u32, nrulepriority: i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszrulename: super::super::Foundation::PWSTR, ulruleid: u32, flweight: f32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flweight: f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ploader: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com_Urlmon")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psmlsecuritymanager: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com_Urlmon"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoResult(pub ::windows::core::IUnknown);
impl ISpRecoResult {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetResultTimes(&self, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ptimes)).ok()
}
pub unsafe fn GetAlternates(&self, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::core::option::Option<ISpPhraseAlt>, pcphrasesreturned: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(ulrequestcount), ::core::mem::transmute(ppphrases), ::core::mem::transmute(pcphrasesreturned)).ok()
}
pub unsafe fn GetAudio(&self, ulstartelement: u32, celements: u32) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
pub unsafe fn SpeakAudio(&self, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(dwflags), ::core::mem::transmute(pulstreamnumber)).ok()
}
pub unsafe fn Serialize(&self, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppcomemserializedresult)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn ScaleAudio(&self, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(paudioformatid), ::core::mem::transmute(pwaveformatex)).ok()
}
pub unsafe fn GetRecoContext(&self) -> ::windows::core::Result<ISpRecoContext> {
let mut result__: <ISpRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecoContext>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpRecoResult {
type Vtable = ISpRecoResult_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x20b053be_e235_43cd_9a2a_8d17a48b7842);
}
impl ::core::convert::From<ISpRecoResult> for ::windows::core::IUnknown {
fn from(value: ISpRecoResult) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoResult> for ::windows::core::IUnknown {
fn from(value: &ISpRecoResult) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRecoResult> for ISpPhrase {
fn from(value: ISpRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoResult> for ISpPhrase {
fn from(value: &ISpRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for ISpRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for &ISpRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoResult_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::windows::core::RawPtr, pcphrasesreturned: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecoResult2(pub ::windows::core::IUnknown);
impl ISpRecoResult2 {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetResultTimes(&self, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ptimes)).ok()
}
pub unsafe fn GetAlternates(&self, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::core::option::Option<ISpPhraseAlt>, pcphrasesreturned: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(ulrequestcount), ::core::mem::transmute(ppphrases), ::core::mem::transmute(pcphrasesreturned)).ok()
}
pub unsafe fn GetAudio(&self, ulstartelement: u32, celements: u32) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
pub unsafe fn SpeakAudio(&self, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(dwflags), ::core::mem::transmute(pulstreamnumber)).ok()
}
pub unsafe fn Serialize(&self, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppcomemserializedresult)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn ScaleAudio(&self, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(paudioformatid), ::core::mem::transmute(pwaveformatex)).ok()
}
pub unsafe fn GetRecoContext(&self) -> ::windows::core::Result<ISpRecoContext> {
let mut result__: <ISpRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecoContext>(result__)
}
pub unsafe fn CommitAlternate<'a, Param0: ::windows::core::IntoParam<'a, ISpPhraseAlt>>(&self, pphrasealt: Param0) -> ::windows::core::Result<ISpRecoResult> {
let mut result__: <ISpRecoResult as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), pphrasealt.into_param().abi(), &mut result__).from_abi::<ISpRecoResult>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CommitText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, ulstartelement: u32, celements: u32, pszcorrecteddata: Param2, ecommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), pszcorrecteddata.into_param().abi(), ::core::mem::transmute(ecommitflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextFeedback<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pszfeedback: Param0, fsuccessful: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), pszfeedback.into_param().abi(), fsuccessful.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecoResult2 {
type Vtable = ISpRecoResult2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x27cac6c4_88f2_41f2_8817_0c95e59f1e6e);
}
impl ::core::convert::From<ISpRecoResult2> for ::windows::core::IUnknown {
fn from(value: ISpRecoResult2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecoResult2> for ::windows::core::IUnknown {
fn from(value: &ISpRecoResult2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRecoResult2> for ISpRecoResult {
fn from(value: ISpRecoResult2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoResult2> for ISpRecoResult {
fn from(value: &ISpRecoResult2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpRecoResult> for ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpRecoResult> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpRecoResult> for &ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpRecoResult> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpRecoResult2> for ISpPhrase {
fn from(value: ISpRecoResult2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecoResult2> for ISpPhrase {
fn from(value: &ISpRecoResult2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for &ISpRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecoResult2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::windows::core::RawPtr, pcphrasesreturned: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pphrasealt: ::windows::core::RawPtr, ppnewresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, pszcorrecteddata: super::super::Foundation::PWSTR, ecommitflags: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszfeedback: super::super::Foundation::PWSTR, fsuccessful: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecognizer(pub ::windows::core::IUnknown);
impl ISpRecognizer {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyNum<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, lvalue: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pname.into_param().abi(), ::core::mem::transmute(lvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyNum<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, plvalue: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pname.into_param().abi(), ::core::mem::transmute(plvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0, pvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pname.into_param().abi(), pvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pname: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pname.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
pub unsafe fn SetRecognizer<'a, Param0: ::windows::core::IntoParam<'a, ISpObjectToken>>(&self, precognizer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), precognizer.into_param().abi()).ok()
}
pub unsafe fn GetRecognizer(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetInput<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, punkinput: Param0, fallowformatchanges: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), punkinput.into_param().abi(), fallowformatchanges.into_param().abi()).ok()
}
pub unsafe fn GetInputObjectToken(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
pub unsafe fn GetInputStream(&self) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
pub unsafe fn CreateRecoContext(&self) -> ::windows::core::Result<ISpRecoContext> {
let mut result__: <ISpRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecoContext>(result__)
}
pub unsafe fn GetRecoProfile(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
pub unsafe fn SetRecoProfile<'a, Param0: ::windows::core::IntoParam<'a, ISpObjectToken>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
pub unsafe fn IsSharedInstance(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn GetRecoState(&self, pstate: *mut SPRECOSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstate)).ok()
}
pub unsafe fn SetRecoState(&self, newstate: SPRECOSTATE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(newstate)).ok()
}
pub unsafe fn GetStatus(&self, pstatus: *mut SPRECOGNIZERSTATUS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, waveformattype: SPWAVEFORMATTYPE, pformatid: *mut ::windows::core::GUID, ppcomemwfex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(waveformattype), ::core::mem::transmute(pformatid), ::core::mem::transmute(ppcomemwfex)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, psztypeofui: Param0, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), ::core::mem::transmute(pfsupported)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisplayUI<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hwndparent: Param0, psztitle: Param1, psztypeofui: Param2, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), hwndparent.into_param().abi(), psztitle.into_param().abi(), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata)).ok()
}
pub unsafe fn EmulateRecognition<'a, Param0: ::windows::core::IntoParam<'a, ISpPhrase>>(&self, pphrase: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), pphrase.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecognizer {
type Vtable = ISpRecognizer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc2b5f241_daa0_4507_9e16_5a1eaa2b7a5c);
}
impl ::core::convert::From<ISpRecognizer> for ::windows::core::IUnknown {
fn from(value: ISpRecognizer) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecognizer> for ::windows::core::IUnknown {
fn from(value: &ISpRecognizer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRecognizer> for ISpProperties {
fn from(value: ISpRecognizer) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRecognizer> for ISpProperties {
fn from(value: &ISpRecognizer) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpProperties> for ISpRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ISpProperties> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpProperties> for &ISpRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ISpProperties> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecognizer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, lvalue: i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, plvalue: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, pvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pname: super::super::Foundation::PWSTR, ppcomemvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, precognizer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecognizer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkinput: ::windows::core::RawPtr, fallowformatchanges: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppnewctxt: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstate: *mut SPRECOSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newstate: SPRECOSTATE) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut SPRECOGNIZERSTATUS) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, waveformattype: SPWAVEFORMATTYPE, pformatid: *mut ::windows::core::GUID, ppcomemwfex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: super::super::Foundation::HWND, psztitle: super::super::Foundation::PWSTR, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pphrase: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRecognizer2(pub ::windows::core::IUnknown);
impl ISpRecognizer2 {
pub unsafe fn EmulateRecognitionEx<'a, Param0: ::windows::core::IntoParam<'a, ISpPhrase>>(&self, pphrase: Param0, dwcompareflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pphrase.into_param().abi(), ::core::mem::transmute(dwcompareflags)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTrainingState<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, fdoingtraining: Param0, fadaptfromtrainingdata: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), fdoingtraining.into_param().abi(), fadaptfromtrainingdata.into_param().abi()).ok()
}
pub unsafe fn ResetAcousticModelAdaptation(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRecognizer2 {
type Vtable = ISpRecognizer2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8fc6d974_c81e_4098_93c5_0147f61ed4d3);
}
impl ::core::convert::From<ISpRecognizer2> for ::windows::core::IUnknown {
fn from(value: ISpRecognizer2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRecognizer2> for ::windows::core::IUnknown {
fn from(value: &ISpRecognizer2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRecognizer2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRecognizer2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRecognizer2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pphrase: ::windows::core::RawPtr, dwcompareflags: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, fdoingtraining: super::super::Foundation::BOOL, fadaptfromtrainingdata: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpRegDataKey(pub ::windows::core::IUnknown);
impl ISpRegDataKey {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, cbdata: u32, pdata: *const u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(cbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pcbdata), ::core::mem::transmute(pdata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pszvalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), pszvalue.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, dwvalue: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(dwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDWORD<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0, pdwvalue: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi(), ::core::mem::transmute(pdwvalue)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkeyname: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pszsubkeyname.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<ISpDataKey> {
let mut result__: <ISpDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi(), &mut result__).from_abi::<ISpDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszsubkey: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), pszsubkey.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszvaluename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), pszvaluename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: u32) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))]
pub unsafe fn SetKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Registry::HKEY>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, hkey: Param0, freadonly: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), hkey.into_param().abi(), freadonly.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpRegDataKey {
type Vtable = ISpRegDataKey_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x92a66e2b_c830_4149_83df_6fc2ba1e7a5b);
}
impl ::core::convert::From<ISpRegDataKey> for ::windows::core::IUnknown {
fn from(value: ISpRegDataKey) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpRegDataKey> for ::windows::core::IUnknown {
fn from(value: &ISpRegDataKey) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpRegDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpRegDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpRegDataKey> for ISpDataKey {
fn from(value: ISpRegDataKey) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpRegDataKey> for ISpDataKey {
fn from(value: &ISpRegDataKey) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for ISpRegDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpDataKey> for &ISpRegDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ISpDataKey> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpRegDataKey_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, cbdata: u32, pdata: *const u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pcbdata: *mut u32, pdata: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pszvalue: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, ppszvalue: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, dwvalue: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR, pdwvalue: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkeyname: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR, ppsubkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszsubkey: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszvaluename: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszsubkeyname: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: u32, ppszvaluename: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Registry"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hkey: super::super::System::Registry::HKEY, freadonly: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Registry")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpResourceManager(pub ::windows::core::IUnknown);
impl ISpResourceManager {
pub unsafe fn QueryService(&self, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidservice), ::core::mem::transmute(riid), ::core::mem::transmute(ppvobject)).ok()
}
pub unsafe fn SetObject<'a, Param1: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, guidserviceid: *const ::windows::core::GUID, punkobject: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidserviceid), punkobject.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetObject<'a, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, guidserviceid: *const ::windows::core::GUID, objectclsid: *const ::windows::core::GUID, objectiid: *const ::windows::core::GUID, freleasewhenlastexternalrefreleased: Param3, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(guidserviceid), ::core::mem::transmute(objectclsid), ::core::mem::transmute(objectiid), freleasewhenlastexternalrefreleased.into_param().abi(), ::core::mem::transmute(ppobject)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpResourceManager {
type Vtable = ISpResourceManager_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x93384e18_5014_43d5_adbb_a78e055926bd);
}
impl ::core::convert::From<ISpResourceManager> for ::windows::core::IUnknown {
fn from(value: ISpResourceManager) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpResourceManager> for ::windows::core::IUnknown {
fn from(value: &ISpResourceManager) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpResourceManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpResourceManager {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpResourceManager> for super::super::System::Com::IServiceProvider {
fn from(value: ISpResourceManager) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpResourceManager> for super::super::System::Com::IServiceProvider {
fn from(value: &ISpResourceManager) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IServiceProvider> for ISpResourceManager {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IServiceProvider> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IServiceProvider> for &ISpResourceManager {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IServiceProvider> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpResourceManager_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidservice: *const ::windows::core::GUID, riid: *const ::windows::core::GUID, ppvobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidserviceid: *const ::windows::core::GUID, punkobject: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guidserviceid: *const ::windows::core::GUID, objectclsid: *const ::windows::core::GUID, objectiid: *const ::windows::core::GUID, freleasewhenlastexternalrefreleased: super::super::Foundation::BOOL, ppobject: *mut *mut ::core::ffi::c_void) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpSerializeState(pub ::windows::core::IUnknown);
impl ISpSerializeState {
pub unsafe fn GetSerializedState(&self, ppbdata: *mut *mut u8, pulsize: *mut u32, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppbdata), ::core::mem::transmute(pulsize), ::core::mem::transmute(dwreserved)).ok()
}
pub unsafe fn SetSerializedState(&self, pbdata: *const u8, ulsize: u32, dwreserved: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pbdata), ::core::mem::transmute(ulsize), ::core::mem::transmute(dwreserved)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpSerializeState {
type Vtable = ISpSerializeState_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x21b501a0_0ec7_46c9_92c3_a2bc784c54b9);
}
impl ::core::convert::From<ISpSerializeState> for ::windows::core::IUnknown {
fn from(value: ISpSerializeState) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpSerializeState> for ::windows::core::IUnknown {
fn from(value: &ISpSerializeState) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpSerializeState {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpSerializeState {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpSerializeState_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppbdata: *mut *mut u8, pulsize: *mut u32, dwreserved: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbdata: *const u8, ulsize: u32, dwreserved: u32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpShortcut(pub ::windows::core::IUnknown);
impl ISpShortcut {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddShortcut<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszdisplay: Param0, langid: u16, pszspoken: Param2, shtype: SPSHORTCUTTYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pszdisplay.into_param().abi(), ::core::mem::transmute(langid), pszspoken.into_param().abi(), ::core::mem::transmute(shtype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveShortcut<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszdisplay: Param0, langid: u16, pszspoken: Param2, shtype: SPSHORTCUTTYPE) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), pszdisplay.into_param().abi(), ::core::mem::transmute(langid), pszspoken.into_param().abi(), ::core::mem::transmute(shtype)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetShortcuts(&self, langid: u16, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(langid), ::core::mem::transmute(pshortcutpairlist)).ok()
}
pub unsafe fn GetGeneration(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWordsFromGenerationChange(&self, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pwordlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetWords(&self, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pdwcookie), ::core::mem::transmute(pwordlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetShortcutsForGeneration(&self, pdwgeneration: *mut u32, pdwcookie: *mut u32, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pdwcookie), ::core::mem::transmute(pshortcutpairlist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetGenerationChange(&self, pdwgeneration: *mut u32, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(pdwgeneration), ::core::mem::transmute(pshortcutpairlist)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpShortcut {
type Vtable = ISpShortcut_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3df681e2_ea56_11d9_8bde_f66bad1e3f3a);
}
impl ::core::convert::From<ISpShortcut> for ::windows::core::IUnknown {
fn from(value: ISpShortcut) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpShortcut> for ::windows::core::IUnknown {
fn from(value: &ISpShortcut) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpShortcut {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpShortcut {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpShortcut_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdisplay: super::super::Foundation::PWSTR, langid: u16, pszspoken: super::super::Foundation::PWSTR, shtype: SPSHORTCUTTYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszdisplay: super::super::Foundation::PWSTR, langid: u16, pszspoken: super::super::Foundation::PWSTR, shtype: SPSHORTCUTTYPE) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, langid: u16, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32, pdwcookie: *mut u32, pwordlist: *mut SPWORDLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32, pdwcookie: *mut u32, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdwgeneration: *mut u32, pshortcutpairlist: *mut SPSHORTCUTPAIRLIST) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpStream(pub ::windows::core::IUnknown);
impl ISpStream {
pub unsafe fn Read(&self, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn Write(&self, pv: *const ::core::ffi::c_void, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Seek(&self, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dlibmove), ::core::mem::transmute(dworigin), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetSize(&self, libnewsize: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(libnewsize)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CopyTo<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstm: Param0, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstm.into_param().abi(), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread), ::core::mem::transmute(pcbwritten)).ok()
}
pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(grfcommitflags)).ok()
}
pub unsafe fn Revert(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn Stat(&self, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatstg), ::core::mem::transmute(grfstatflag)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Clone(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, pguidformatid: *const ::windows::core::GUID) -> ::windows::core::Result<*mut super::Audio::WAVEFORMATEX> {
let mut result__: <*mut super::Audio::WAVEFORMATEX as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidformatid), &mut result__).from_abi::<*mut super::Audio::WAVEFORMATEX>(result__)
}
#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))]
pub unsafe fn SetBaseStream<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstream: Param0, rguidformat: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pstream.into_param().abi(), ::core::mem::transmute(rguidformat), ::core::mem::transmute(pwaveformatex)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetBaseStream(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_Audio"))]
pub unsafe fn BindToFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pszfilename: Param0, emode: SPFILEMODE, pformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX, ulleventinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), pszfilename.into_param().abi(), ::core::mem::transmute(emode), ::core::mem::transmute(pformatid), ::core::mem::transmute(pwaveformatex), ::core::mem::transmute(ulleventinterest)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpStream {
type Vtable = ISpStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x12e3cca9_7518_44c5_a5e7_ba5a79cb929e);
}
impl ::core::convert::From<ISpStream> for ::windows::core::IUnknown {
fn from(value: ISpStream) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpStream> for ::windows::core::IUnknown {
fn from(value: &ISpStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpStream> for ISpStreamFormat {
fn from(value: ISpStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpStream> for ISpStreamFormat {
fn from(value: &ISpStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for &ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStream> for super::super::System::Com::IStream {
fn from(value: ISpStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStream> for super::super::System::Com::IStream {
fn from(value: &ISpStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for &ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStream> for super::super::System::Com::ISequentialStream {
fn from(value: ISpStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStream> for super::super::System::Com::ISequentialStream {
fn from(value: &ISpStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for &ISpStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *const ::core::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK, plibnewposition: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, libnewsize: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstm: ::windows::core::RawPtr, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grfcommitflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstm: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidformatid: *const ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, rguidformat: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Media_Audio", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_Media_Audio"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pszfilename: super::super::Foundation::PWSTR, emode: SPFILEMODE, pformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX, ulleventinterest: u64) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_Media_Audio")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpStreamFormat(pub ::windows::core::IUnknown);
impl ISpStreamFormat {
pub unsafe fn Read(&self, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn Write(&self, pv: *const ::core::ffi::c_void, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Seek(&self, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dlibmove), ::core::mem::transmute(dworigin), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetSize(&self, libnewsize: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(libnewsize)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CopyTo<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstm: Param0, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstm.into_param().abi(), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread), ::core::mem::transmute(pcbwritten)).ok()
}
pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(grfcommitflags)).ok()
}
pub unsafe fn Revert(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn Stat(&self, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatstg), ::core::mem::transmute(grfstatflag)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Clone(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, pguidformatid: *const ::windows::core::GUID) -> ::windows::core::Result<*mut super::Audio::WAVEFORMATEX> {
let mut result__: <*mut super::Audio::WAVEFORMATEX as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidformatid), &mut result__).from_abi::<*mut super::Audio::WAVEFORMATEX>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpStreamFormat {
type Vtable = ISpStreamFormat_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbed530be_2606_4f4d_a1c0_54c5cda5566f);
}
impl ::core::convert::From<ISpStreamFormat> for ::windows::core::IUnknown {
fn from(value: ISpStreamFormat) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpStreamFormat> for ::windows::core::IUnknown {
fn from(value: &ISpStreamFormat) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStreamFormat> for super::super::System::Com::IStream {
fn from(value: ISpStreamFormat) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStreamFormat> for super::super::System::Com::IStream {
fn from(value: &ISpStreamFormat) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for &ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStreamFormat> for super::super::System::Com::ISequentialStream {
fn from(value: ISpStreamFormat) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStreamFormat> for super::super::System::Com::ISequentialStream {
fn from(value: &ISpStreamFormat) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for &ISpStreamFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpStreamFormat_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *const ::core::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK, plibnewposition: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, libnewsize: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstm: ::windows::core::RawPtr, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grfcommitflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstm: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidformatid: *const ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpStreamFormatConverter(pub ::windows::core::IUnknown);
impl ISpStreamFormatConverter {
pub unsafe fn Read(&self, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread)).ok()
}
pub unsafe fn Write(&self, pv: *const ::core::ffi::c_void, cb: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(pv), ::core::mem::transmute(cb), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Seek(&self, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(dlibmove), ::core::mem::transmute(dworigin), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn SetSize(&self, libnewsize: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(libnewsize)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn CopyTo<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstm: Param0, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), pstm.into_param().abi(), ::core::mem::transmute(cb), ::core::mem::transmute(pcbread), ::core::mem::transmute(pcbwritten)).ok()
}
pub unsafe fn Commit(&self, grfcommitflags: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(grfcommitflags)).ok()
}
pub unsafe fn Revert(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn LockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
pub unsafe fn UnlockRegion(&self, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(liboffset), ::core::mem::transmute(cb), ::core::mem::transmute(dwlocktype)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))]
pub unsafe fn Stat(&self, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatstg), ::core::mem::transmute(grfstatflag)).ok()
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn Clone(&self) -> ::windows::core::Result<super::super::System::Com::IStream> {
let mut result__: <super::super::System::Com::IStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::IStream>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn GetFormat(&self, pguidformatid: *const ::windows::core::GUID) -> ::windows::core::Result<*mut super::Audio::WAVEFORMATEX> {
let mut result__: <*mut super::Audio::WAVEFORMATEX as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(pguidformatid), &mut result__).from_abi::<*mut super::Audio::WAVEFORMATEX>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetBaseStream<'a, Param0: ::windows::core::IntoParam<'a, ISpStreamFormat>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, pstream: Param0, fsetformattobasestreamformat: Param1, fwritetobasestream: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), pstream.into_param().abi(), fsetformattobasestreamformat.into_param().abi(), fwritetobasestream.into_param().abi()).ok()
}
pub unsafe fn GetBaseStream(&self) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn SetFormat(&self, rguidformatidofconvertedstream: *const ::windows::core::GUID, pwaveformatexofconvertedstream: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(rguidformatidofconvertedstream), ::core::mem::transmute(pwaveformatexofconvertedstream)).ok()
}
pub unsafe fn ResetSeekPosition(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn ScaleConvertedToBaseOffset(&self, ulloffsetconvertedstream: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulloffsetconvertedstream), &mut result__).from_abi::<u64>(result__)
}
pub unsafe fn ScaleBaseToConvertedOffset(&self, ulloffsetbasestream: u64) -> ::windows::core::Result<u64> {
let mut result__: <u64 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulloffsetbasestream), &mut result__).from_abi::<u64>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpStreamFormatConverter {
type Vtable = ISpStreamFormatConverter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x678a932c_ea71_4446_9b41_78fda6280a29);
}
impl ::core::convert::From<ISpStreamFormatConverter> for ::windows::core::IUnknown {
fn from(value: ISpStreamFormatConverter) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpStreamFormatConverter> for ::windows::core::IUnknown {
fn from(value: &ISpStreamFormatConverter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpStreamFormatConverter> for ISpStreamFormat {
fn from(value: ISpStreamFormatConverter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpStreamFormatConverter> for ISpStreamFormat {
fn from(value: &ISpStreamFormatConverter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpStreamFormat> for &ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, ISpStreamFormat> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStreamFormatConverter> for super::super::System::Com::IStream {
fn from(value: ISpStreamFormatConverter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStreamFormatConverter> for super::super::System::Com::IStream {
fn from(value: &ISpStreamFormatConverter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IStream> for &ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpStreamFormatConverter> for super::super::System::Com::ISequentialStream {
fn from(value: ISpStreamFormatConverter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpStreamFormatConverter> for super::super::System::Com::ISequentialStream {
fn from(value: &ISpStreamFormatConverter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::ISequentialStream> for &ISpStreamFormatConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::ISequentialStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpStreamFormatConverter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *mut ::core::ffi::c_void, cb: u32, pcbread: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pv: *const ::core::ffi::c_void, cb: u32, pcbwritten: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dlibmove: i64, dworigin: super::super::System::Com::STREAM_SEEK, plibnewposition: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, libnewsize: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstm: ::windows::core::RawPtr, cb: u64, pcbread: *mut u64, pcbwritten: *mut u64) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grfcommitflags: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, liboffset: u64, cb: u64, dwlocktype: u32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatstg: *mut super::super::System::Com::STATSTG, grfstatflag: u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com")))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstm: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pguidformatid: *const ::windows::core::GUID, ppcomemwaveformatex: *mut *mut super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, fsetformattobasestreamformat: super::super::Foundation::BOOL, fwritetobasestream: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rguidformatidofconvertedstream: *const ::windows::core::GUID, pwaveformatexofconvertedstream: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulloffsetconvertedstream: u64, pulloffsetbasestream: *mut u64) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulloffsetbasestream: u64, pulloffsetconvertedstream: *mut u64) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpTranscript(pub ::windows::core::IUnknown);
impl ISpTranscript {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetTranscript(&self) -> ::windows::core::Result<super::super::Foundation::PWSTR> {
let mut result__: <super::super::Foundation::PWSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::PWSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AppendTranscript<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, psztranscript: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), psztranscript.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpTranscript {
type Vtable = ISpTranscript_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x10f63bce_201a_11d3_ac70_00c04f8ee6c0);
}
impl ::core::convert::From<ISpTranscript> for ::windows::core::IUnknown {
fn from(value: ISpTranscript) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpTranscript> for ::windows::core::IUnknown {
fn from(value: &ISpTranscript) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpTranscript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpTranscript {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpTranscript_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppsztranscript: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztranscript: super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpVoice(pub ::windows::core::IUnknown);
impl ISpVoice {
pub unsafe fn SetNotifySink<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifySink>>(&self, pnotifysink: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), pnotifysink.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyWindowMessage<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, hwnd: Param0, msg: u32, wparam: Param2, lparam: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), hwnd.into_param().abi(), ::core::mem::transmute(msg), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackFunction<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pfncallback: *mut ::core::option::Option<SPNOTIFYCALLBACK>, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(pfncallback), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetNotifyCallbackInterface<'a, Param0: ::windows::core::IntoParam<'a, ISpNotifyCallback>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::WPARAM>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::LPARAM>>(&self, pspcallback: Param0, wparam: Param1, lparam: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), pspcallback.into_param().abi(), wparam.into_param().abi(), lparam.into_param().abi()).ok()
}
pub unsafe fn SetNotifyWin32Event(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn WaitForNotifyEvent(&self, dwmilliseconds: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwmilliseconds)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetNotifyEventHandle(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self)))
}
pub unsafe fn SetInterest(&self, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulleventinterest), ::core::mem::transmute(ullqueuedinterest)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetEvents(&self, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulcount), ::core::mem::transmute(peventarray), ::core::mem::transmute(pulfetched)).ok()
}
pub unsafe fn GetInfo(&self, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(pinfo)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetOutput<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, punkoutput: Param0, fallowformatchanges: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), punkoutput.into_param().abi(), fallowformatchanges.into_param().abi()).ok()
}
pub unsafe fn GetOutputObjectToken(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
pub unsafe fn GetOutputStream(&self) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn SetVoice<'a, Param0: ::windows::core::IntoParam<'a, ISpObjectToken>>(&self, ptoken: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ptoken.into_param().abi()).ok()
}
pub unsafe fn GetVoice(&self) -> ::windows::core::Result<ISpObjectToken> {
let mut result__: <ISpObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpObjectToken>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Speak<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pwcs: Param0, dwflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), pwcs.into_param().abi(), ::core::mem::transmute(dwflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn SpeakStream<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::IStream>>(&self, pstream: Param0, dwflags: u32) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), pstream.into_param().abi(), ::core::mem::transmute(dwflags), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStatus(&self, pstatus: *mut SPVOICESTATUS, ppszlastbookmark: *mut super::super::Foundation::PWSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(pstatus), ::core::mem::transmute(ppszlastbookmark)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Skip<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, pitemtype: Param0, lnumitems: i32, pulnumskipped: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), pitemtype.into_param().abi(), ::core::mem::transmute(lnumitems), ::core::mem::transmute(pulnumskipped)).ok()
}
pub unsafe fn SetPriority(&self, epriority: SPVPRIORITY) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(epriority)).ok()
}
pub unsafe fn GetPriority(&self, pepriority: *mut SPVPRIORITY) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), ::core::mem::transmute(pepriority)).ok()
}
pub unsafe fn SetAlertBoundary(&self, eboundary: SPEVENTENUM) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(eboundary)).ok()
}
pub unsafe fn GetAlertBoundary(&self, peboundary: *mut SPEVENTENUM) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), ::core::mem::transmute(peboundary)).ok()
}
pub unsafe fn SetRate(&self, rateadjust: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), ::core::mem::transmute(rateadjust)).ok()
}
pub unsafe fn GetRate(&self, prateadjust: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(prateadjust)).ok()
}
pub unsafe fn SetVolume(&self, usvolume: u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(usvolume)).ok()
}
pub unsafe fn GetVolume(&self, pusvolume: *mut u16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), ::core::mem::transmute(pusvolume)).ok()
}
pub unsafe fn WaitUntilDone(&self, mstimeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), ::core::mem::transmute(mstimeout)).ok()
}
pub unsafe fn SetSyncSpeakTimeout(&self, mstimeout: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), ::core::mem::transmute(mstimeout)).ok()
}
pub unsafe fn GetSyncSpeakTimeout(&self, pmstimeout: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), ::core::mem::transmute(pmstimeout)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SpeakCompleteEvent(&self) -> super::super::Foundation::HANDLE {
::core::mem::transmute((::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self)))
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, psztypeofui: Param0, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata), ::core::mem::transmute(pfsupported)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisplayUI<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::HWND>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::PWSTR>>(&self, hwndparent: Param0, psztitle: Param1, psztypeofui: Param2, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), hwndparent.into_param().abi(), psztitle.into_param().abi(), psztypeofui.into_param().abi(), ::core::mem::transmute(pvextradata), ::core::mem::transmute(cbextradata)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpVoice {
type Vtable = ISpVoice_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6c44df74_72b9_4992_a1ec_ef996e0422d4);
}
impl ::core::convert::From<ISpVoice> for ::windows::core::IUnknown {
fn from(value: ISpVoice) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpVoice> for ::windows::core::IUnknown {
fn from(value: &ISpVoice) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpVoice> for ISpEventSource {
fn from(value: ISpVoice) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpVoice> for ISpEventSource {
fn from(value: &ISpVoice) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpEventSource> for &ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ISpEventSource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpVoice> for ISpNotifySource {
fn from(value: ISpVoice) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpVoice> for ISpNotifySource {
fn from(value: &ISpVoice) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpNotifySource> for &ISpVoice {
fn into_param(self) -> ::windows::core::Param<'a, ISpNotifySource> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpVoice_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pnotifysink: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: super::super::Foundation::HWND, msg: u32, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pfncallback: *mut ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pspcallback: ::windows::core::RawPtr, wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwmilliseconds: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulleventinterest: u64, ullqueuedinterest: u64) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulcount: u32, peventarray: *mut SPEVENT, pulfetched: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pinfo: *mut SPEVENTSOURCEINFO) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkoutput: ::windows::core::RawPtr, fallowformatchanges: super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppobjecttoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptoken: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pptoken: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pwcs: super::super::Foundation::PWSTR, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstream: ::windows::core::RawPtr, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pstatus: *mut SPVOICESTATUS, ppszlastbookmark: *mut super::super::Foundation::PWSTR) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pitemtype: super::super::Foundation::PWSTR, lnumitems: i32, pulnumskipped: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, epriority: SPVPRIORITY) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pepriority: *mut SPVPRIORITY) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eboundary: SPEVENTENUM) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, peboundary: *mut SPEVENTENUM) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rateadjust: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, prateadjust: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, usvolume: u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pusvolume: *mut u16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mstimeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mstimeout: u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pmstimeout: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> super::super::Foundation::HANDLE,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32, pfsupported: *mut super::super::Foundation::BOOL) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: super::super::Foundation::HWND, psztitle: super::super::Foundation::PWSTR, psztypeofui: super::super::Foundation::PWSTR, pvextradata: *mut ::core::ffi::c_void, cbextradata: u32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpXMLRecoResult(pub ::windows::core::IUnknown);
impl ISpXMLRecoResult {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetPhrase(&self) -> ::windows::core::Result<*mut SPPHRASE> {
let mut result__: <*mut SPPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPPHRASE>(result__)
}
pub unsafe fn GetSerializedPhrase(&self) -> ::windows::core::Result<*mut SPSERIALIZEDPHRASE> {
let mut result__: <*mut SPSERIALIZEDPHRASE as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), &mut result__).from_abi::<*mut SPSERIALIZEDPHRASE>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText<'a, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BOOL>>(&self, ulstart: u32, ulcount: u32, fusetextreplacements: Param2, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstart), ::core::mem::transmute(ulcount), fusetextreplacements.into_param().abi(), ::core::mem::transmute(ppszcomemtext), ::core::mem::transmute(pbdisplayattributes)).ok()
}
pub unsafe fn Discard(&self, dwvaluetypes: u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(::core::mem::transmute_copy(self), ::core::mem::transmute(dwvaluetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetResultTimes(&self, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(ptimes)).ok()
}
pub unsafe fn GetAlternates(&self, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::core::option::Option<ISpPhraseAlt>, pcphrasesreturned: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(ulrequestcount), ::core::mem::transmute(ppphrases), ::core::mem::transmute(pcphrasesreturned)).ok()
}
pub unsafe fn GetAudio(&self, ulstartelement: u32, celements: u32) -> ::windows::core::Result<ISpStreamFormat> {
let mut result__: <ISpStreamFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), &mut result__).from_abi::<ISpStreamFormat>(result__)
}
pub unsafe fn SpeakAudio(&self, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(ulstartelement), ::core::mem::transmute(celements), ::core::mem::transmute(dwflags), ::core::mem::transmute(pulstreamnumber)).ok()
}
pub unsafe fn Serialize(&self, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppcomemserializedresult)).ok()
}
#[cfg(feature = "Win32_Media_Audio")]
pub unsafe fn ScaleAudio(&self, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(paudioformatid), ::core::mem::transmute(pwaveformatex)).ok()
}
pub unsafe fn GetRecoContext(&self) -> ::windows::core::Result<ISpRecoContext> {
let mut result__: <ISpRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpRecoContext>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLResult(&self, ppszcomemxmlresult: *mut super::super::Foundation::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(ppszcomemxmlresult), ::core::mem::transmute(options)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLErrorInfo(&self, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(psemanticerrorinfo)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpXMLRecoResult {
type Vtable = ISpXMLRecoResult_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xae39362b_45a8_4074_9b9e_ccf49aa2d0b6);
}
impl ::core::convert::From<ISpXMLRecoResult> for ::windows::core::IUnknown {
fn from(value: ISpXMLRecoResult) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpXMLRecoResult> for ::windows::core::IUnknown {
fn from(value: &ISpXMLRecoResult) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpXMLRecoResult> for ISpRecoResult {
fn from(value: ISpXMLRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpXMLRecoResult> for ISpRecoResult {
fn from(value: &ISpXMLRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpRecoResult> for ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpRecoResult> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpRecoResult> for &ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpRecoResult> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpXMLRecoResult> for ISpPhrase {
fn from(value: ISpXMLRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpXMLRecoResult> for ISpPhrase {
fn from(value: &ISpXMLRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpPhrase> for &ISpXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpPhrase> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpXMLRecoResult_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPPHRASE) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemphrase: *mut *mut SPSERIALIZEDPHRASE) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstart: u32, ulcount: u32, fusetextreplacements: super::super::Foundation::BOOL, ppszcomemtext: *mut super::super::Foundation::PWSTR, pbdisplayattributes: *mut u8) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dwvaluetypes: u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ptimes: *mut SPRECORESULTTIMES) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ulrequestcount: u32, ppphrases: *mut ::windows::core::RawPtr, pcphrasesreturned: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, ppstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ulstartelement: u32, celements: u32, dwflags: u32, pulstreamnumber: *mut u32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppcomemserializedresult: *mut *mut SPSERIALIZEDRESULT) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Media_Audio")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paudioformatid: *const ::windows::core::GUID, pwaveformatex: *const super::Audio::WAVEFORMATEX) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Media_Audio"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pprecocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppszcomemxmlresult: *mut super::super::Foundation::PWSTR, options: SPXMLRESULTOPTIONS) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, psemanticerrorinfo: *mut SPSEMANTICERRORINFO) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechAudio(pub ::windows::core::IUnknown);
impl ISpeechAudio {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn Status(&self) -> ::windows::core::Result<ISpeechAudioStatus> {
let mut result__: <ISpeechAudioStatus as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioStatus>(result__)
}
pub unsafe fn BufferInfo(&self) -> ::windows::core::Result<ISpeechAudioBufferInfo> {
let mut result__: <ISpeechAudioBufferInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioBufferInfo>(result__)
}
pub unsafe fn DefaultFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn Volume(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetVolume(&self, volume: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
pub unsafe fn BufferNotifySize(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetBufferNotifySize(&self, buffernotifysize: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffernotifysize)).ok()
}
pub unsafe fn EventHandle(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetState(&self, state: SpeechAudioState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechAudio {
type Vtable = ISpeechAudio_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcff8e175_019e_11d3_a08e_00c04f8ef9b5);
}
impl ::core::convert::From<ISpeechAudio> for ::windows::core::IUnknown {
fn from(value: ISpeechAudio) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechAudio> for ::windows::core::IUnknown {
fn from(value: &ISpeechAudio) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechAudio> for ISpeechBaseStream {
fn from(value: ISpeechAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechAudio> for ISpeechBaseStream {
fn from(value: &ISpeechAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for &ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechAudio> for super::super::System::Com::IDispatch {
fn from(value: ISpeechAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechAudio> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechAudio_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bufferinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffernotifysize: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffernotifysize: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventhandle: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechAudioState) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechAudioBufferInfo(pub ::windows::core::IUnknown);
impl ISpeechAudioBufferInfo {
pub unsafe fn MinNotification(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetMinNotification(&self, minnotification: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(minnotification)).ok()
}
pub unsafe fn BufferSize(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetBufferSize(&self, buffersize: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffersize)).ok()
}
pub unsafe fn EventBias(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetEventBias(&self, eventbias: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventbias)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechAudioBufferInfo {
type Vtable = ISpeechAudioBufferInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x11b103d8_1142_4edf_a093_82fb3915f8cc);
}
impl ::core::convert::From<ISpeechAudioBufferInfo> for ::windows::core::IUnknown {
fn from(value: ISpeechAudioBufferInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechAudioBufferInfo> for ::windows::core::IUnknown {
fn from(value: &ISpeechAudioBufferInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechAudioBufferInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechAudioBufferInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechAudioBufferInfo> for super::super::System::Com::IDispatch {
fn from(value: ISpeechAudioBufferInfo) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechAudioBufferInfo> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechAudioBufferInfo) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechAudioBufferInfo {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechAudioBufferInfo {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechAudioBufferInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, minnotification: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, minnotification: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffersize: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffersize: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventbias: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventbias: i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechAudioFormat(pub ::windows::core::IUnknown);
impl ISpeechAudioFormat {
pub unsafe fn Type(&self) -> ::windows::core::Result<SpeechAudioFormatType> {
let mut result__: <SpeechAudioFormatType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechAudioFormatType>(result__)
}
pub unsafe fn SetType(&self, audioformat: SpeechAudioFormatType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(audioformat)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Guid(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetGuid<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, guid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), guid.into_param().abi()).ok()
}
pub unsafe fn GetWaveFormatEx(&self) -> ::windows::core::Result<ISpeechWaveFormatEx> {
let mut result__: <ISpeechWaveFormatEx as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechWaveFormatEx>(result__)
}
pub unsafe fn SetWaveFormatEx<'a, Param0: ::windows::core::IntoParam<'a, ISpeechWaveFormatEx>>(&self, speechwaveformatex: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), speechwaveformatex.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechAudioFormat {
type Vtable = ISpeechAudioFormat_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6e9c590_3e18_40e3_8299_061f98bde7c7);
}
impl ::core::convert::From<ISpeechAudioFormat> for ::windows::core::IUnknown {
fn from(value: ISpeechAudioFormat) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechAudioFormat> for ::windows::core::IUnknown {
fn from(value: &ISpeechAudioFormat) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechAudioFormat {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechAudioFormat {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechAudioFormat> for super::super::System::Com::IDispatch {
fn from(value: ISpeechAudioFormat) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechAudioFormat> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechAudioFormat) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechAudioFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechAudioFormat {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechAudioFormat_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut SpeechAudioFormatType) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: SpeechAudioFormatType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, guid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, speechwaveformatex: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, speechwaveformatex: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechAudioStatus(pub ::windows::core::IUnknown);
impl ISpeechAudioStatus {
pub unsafe fn FreeBufferSpace(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NonBlockingIO(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn State(&self) -> ::windows::core::Result<SpeechAudioState> {
let mut result__: <SpeechAudioState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechAudioState>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CurrentSeekPosition(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CurrentDevicePosition(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechAudioStatus {
type Vtable = ISpeechAudioStatus_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc62d9c91_7458_47f6_862d_1ef86fb0b278);
}
impl ::core::convert::From<ISpeechAudioStatus> for ::windows::core::IUnknown {
fn from(value: ISpeechAudioStatus) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechAudioStatus> for ::windows::core::IUnknown {
fn from(value: &ISpeechAudioStatus) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechAudioStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechAudioStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechAudioStatus> for super::super::System::Com::IDispatch {
fn from(value: ISpeechAudioStatus) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechAudioStatus> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechAudioStatus) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechAudioStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechAudioStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechAudioStatus_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, freebufferspace: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nonblockingio: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut SpeechAudioState) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, currentseekposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, currentdeviceposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechBaseStream(pub ::windows::core::IUnknown);
impl ISpeechBaseStream {
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechBaseStream {
type Vtable = ISpeechBaseStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6450336f_7d49_4ced_8097_49d6dee37294);
}
impl ::core::convert::From<ISpeechBaseStream> for ::windows::core::IUnknown {
fn from(value: ISpeechBaseStream) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechBaseStream> for ::windows::core::IUnknown {
fn from(value: &ISpeechBaseStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechBaseStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechBaseStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechBaseStream> for super::super::System::Com::IDispatch {
fn from(value: ISpeechBaseStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechBaseStream> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechBaseStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechBaseStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechBaseStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechBaseStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechCustomStream(pub ::windows::core::IUnknown);
impl ISpeechCustomStream {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn BaseStream(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn putref_BaseStream<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkstream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), punkstream.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechCustomStream {
type Vtable = ISpeechCustomStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x1a9e9f4f_104f_4db8_a115_efd7fd0c97ae);
}
impl ::core::convert::From<ISpeechCustomStream> for ::windows::core::IUnknown {
fn from(value: ISpeechCustomStream) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechCustomStream> for ::windows::core::IUnknown {
fn from(value: &ISpeechCustomStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechCustomStream> for ISpeechBaseStream {
fn from(value: ISpeechCustomStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechCustomStream> for ISpeechBaseStream {
fn from(value: &ISpeechCustomStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for &ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechCustomStream> for super::super::System::Com::IDispatch {
fn from(value: ISpeechCustomStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechCustomStream> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechCustomStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechCustomStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechCustomStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppunkstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkstream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechDataKey(pub ::windows::core::IUnknown);
impl ISpeechDataKey {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetBinaryValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, valuename: Param0, value: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), valuename.into_param().abi(), value.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetBinaryValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), valuename.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0, value: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), valuename.into_param().abi(), value.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStringValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), valuename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetLongValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0, value: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), valuename.into_param().abi(), ::core::mem::transmute(value)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLongValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), valuename.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn OpenKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, subkeyname: Param0) -> ::windows::core::Result<ISpeechDataKey> {
let mut result__: <ISpeechDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), subkeyname.into_param().abi(), &mut result__).from_abi::<ISpeechDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CreateKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, subkeyname: Param0) -> ::windows::core::Result<ISpeechDataKey> {
let mut result__: <ISpeechDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), subkeyname.into_param().abi(), &mut result__).from_abi::<ISpeechDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteKey<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, subkeyname: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), subkeyname.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DeleteValue<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, valuename: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), valuename.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumKeys(&self, index: i32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumValues(&self, index: i32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechDataKey {
type Vtable = ISpeechDataKey_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xce17c09b_4efa_44d5_a4c9_59d9585ab0cd);
}
impl ::core::convert::From<ISpeechDataKey> for ::windows::core::IUnknown {
fn from(value: ISpeechDataKey) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechDataKey> for ::windows::core::IUnknown {
fn from(value: &ISpeechDataKey) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechDataKey {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechDataKey> for super::super::System::Com::IDispatch {
fn from(value: ISpeechDataKey) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechDataKey> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechDataKey) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechDataKey {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechDataKey {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechDataKey_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, subkeyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, subkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, subkeyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, subkey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, subkeyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, subkeyname: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, valuename: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechFileStream(pub ::windows::core::IUnknown);
impl ISpeechFileStream {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Open<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filename: Param0, filemode: SpeechStreamFileMode, doevents: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(filemode), ::core::mem::transmute(doevents)).ok()
}
pub unsafe fn Close(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechFileStream {
type Vtable = ISpeechFileStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaf67f125_ab39_4e93_b4a2_cc2e66e182a7);
}
impl ::core::convert::From<ISpeechFileStream> for ::windows::core::IUnknown {
fn from(value: ISpeechFileStream) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechFileStream> for ::windows::core::IUnknown {
fn from(value: &ISpeechFileStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechFileStream> for ISpeechBaseStream {
fn from(value: ISpeechFileStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechFileStream> for ISpeechBaseStream {
fn from(value: &ISpeechFileStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for &ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechFileStream> for super::super::System::Com::IDispatch {
fn from(value: ISpeechFileStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechFileStream> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechFileStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechFileStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechFileStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, filemode: SpeechStreamFileMode, doevents: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechGrammarRule(pub ::windows::core::IUnknown);
impl ISpeechGrammarRule {
pub unsafe fn Attributes(&self) -> ::windows::core::Result<SpeechRuleAttributes> {
let mut result__: <SpeechRuleAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRuleAttributes>(result__)
}
pub unsafe fn InitialState(&self) -> ::windows::core::Result<ISpeechGrammarRuleState> {
let mut result__: <ISpeechGrammarRuleState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRuleState>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Name(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Id(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Clear(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, resourcename: Param0, resourcevalue: Param1) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), resourcename.into_param().abi(), resourcevalue.into_param().abi()).ok()
}
pub unsafe fn AddState(&self) -> ::windows::core::Result<ISpeechGrammarRuleState> {
let mut result__: <ISpeechGrammarRuleState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRuleState>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechGrammarRule {
type Vtable = ISpeechGrammarRule_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xafe719cf_5dd1_44f2_999c_7a399f1cfccc);
}
impl ::core::convert::From<ISpeechGrammarRule> for ::windows::core::IUnknown {
fn from(value: ISpeechGrammarRule) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechGrammarRule> for ::windows::core::IUnknown {
fn from(value: &ISpeechGrammarRule) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechGrammarRule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechGrammarRule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechGrammarRule> for super::super::System::Com::IDispatch {
fn from(value: ISpeechGrammarRule) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechGrammarRule> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechGrammarRule) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechGrammarRule {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechGrammarRule {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechGrammarRule_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, attributes: *mut SpeechRuleAttributes) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resourcename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, resourcevalue: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechGrammarRuleState(pub ::windows::core::IUnknown);
impl ISpeechGrammarRuleState {
pub unsafe fn Rule(&self) -> ::windows::core::Result<ISpeechGrammarRule> {
let mut result__: <ISpeechGrammarRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRule>(result__)
}
pub unsafe fn Transitions(&self) -> ::windows::core::Result<ISpeechGrammarRuleStateTransitions> {
let mut result__: <ISpeechGrammarRuleStateTransitions as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRuleStateTransitions>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddWordTransition<'a, Param0: ::windows::core::IntoParam<'a, ISpeechGrammarRuleState>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param4: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(
&self,
deststate: Param0,
words: Param1,
separators: Param2,
r#type: SpeechGrammarWordType,
propertyname: Param4,
propertyid: i32,
propertyvalue: *const super::super::System::Com::VARIANT,
weight: f32,
) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), deststate.into_param().abi(), words.into_param().abi(), separators.into_param().abi(), ::core::mem::transmute(r#type), propertyname.into_param().abi(), ::core::mem::transmute(propertyid), ::core::mem::transmute(propertyvalue), ::core::mem::transmute(weight)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddRuleTransition<'a, Param0: ::windows::core::IntoParam<'a, ISpeechGrammarRuleState>, Param1: ::windows::core::IntoParam<'a, ISpeechGrammarRule>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, destinationstate: Param0, rule: Param1, propertyname: Param2, propertyid: i32, propertyvalue: *const super::super::System::Com::VARIANT, weight: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), destinationstate.into_param().abi(), rule.into_param().abi(), propertyname.into_param().abi(), ::core::mem::transmute(propertyid), ::core::mem::transmute(propertyvalue), ::core::mem::transmute(weight)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddSpecialTransition<'a, Param0: ::windows::core::IntoParam<'a, ISpeechGrammarRuleState>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, destinationstate: Param0, r#type: SpeechSpecialTransitionType, propertyname: Param2, propertyid: i32, propertyvalue: *const super::super::System::Com::VARIANT, weight: f32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), destinationstate.into_param().abi(), ::core::mem::transmute(r#type), propertyname.into_param().abi(), ::core::mem::transmute(propertyid), ::core::mem::transmute(propertyvalue), ::core::mem::transmute(weight)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechGrammarRuleState {
type Vtable = ISpeechGrammarRuleState_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xd4286f2c_ee67_45ae_b928_28d695362eda);
}
impl ::core::convert::From<ISpeechGrammarRuleState> for ::windows::core::IUnknown {
fn from(value: ISpeechGrammarRuleState) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechGrammarRuleState> for ::windows::core::IUnknown {
fn from(value: &ISpeechGrammarRuleState) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechGrammarRuleState {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechGrammarRuleState {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechGrammarRuleState> for super::super::System::Com::IDispatch {
fn from(value: ISpeechGrammarRuleState) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechGrammarRuleState> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechGrammarRuleState) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechGrammarRuleState {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechGrammarRuleState {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechGrammarRuleState_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, transitions: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, deststate: ::windows::core::RawPtr, words: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, separators: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, r#type: SpeechGrammarWordType, propertyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, propertyid: i32, propertyvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, weight: f32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, destinationstate: ::windows::core::RawPtr, rule: ::windows::core::RawPtr, propertyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, propertyid: i32, propertyvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, weight: f32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, destinationstate: ::windows::core::RawPtr, r#type: SpeechSpecialTransitionType, propertyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, propertyid: i32, propertyvalue: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, weight: f32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechGrammarRuleStateTransition(pub ::windows::core::IUnknown);
impl ISpeechGrammarRuleStateTransition {
pub unsafe fn Type(&self) -> ::windows::core::Result<SpeechGrammarRuleStateTransitionType> {
let mut result__: <SpeechGrammarRuleStateTransitionType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechGrammarRuleStateTransitionType>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Text(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Rule(&self) -> ::windows::core::Result<ISpeechGrammarRule> {
let mut result__: <ISpeechGrammarRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRule>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Weight(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn PropertyName(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn PropertyId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn PropertyValue(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn NextState(&self) -> ::windows::core::Result<ISpeechGrammarRuleState> {
let mut result__: <ISpeechGrammarRuleState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRuleState>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechGrammarRuleStateTransition {
type Vtable = ISpeechGrammarRuleStateTransition_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcafd1db1_41d1_4a06_9863_e2e81da17a9a);
}
impl ::core::convert::From<ISpeechGrammarRuleStateTransition> for ::windows::core::IUnknown {
fn from(value: ISpeechGrammarRuleStateTransition) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechGrammarRuleStateTransition> for ::windows::core::IUnknown {
fn from(value: &ISpeechGrammarRuleStateTransition) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechGrammarRuleStateTransition {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechGrammarRuleStateTransition {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechGrammarRuleStateTransition> for super::super::System::Com::IDispatch {
fn from(value: ISpeechGrammarRuleStateTransition) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechGrammarRuleStateTransition> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechGrammarRuleStateTransition) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechGrammarRuleStateTransition {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechGrammarRuleStateTransition {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechGrammarRuleStateTransition_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: *mut SpeechGrammarRuleStateTransitionType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, text: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, weight: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, propertyname: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, propertyid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, propertyvalue: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, nextstate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechGrammarRuleStateTransitions(pub ::windows::core::IUnknown);
impl ISpeechGrammarRuleStateTransitions {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechGrammarRuleStateTransition> {
let mut result__: <ISpeechGrammarRuleStateTransition as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechGrammarRuleStateTransition>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechGrammarRuleStateTransitions {
type Vtable = ISpeechGrammarRuleStateTransitions_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeabce657_75bc_44a2_aa7f_c56476742963);
}
impl ::core::convert::From<ISpeechGrammarRuleStateTransitions> for ::windows::core::IUnknown {
fn from(value: ISpeechGrammarRuleStateTransitions) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechGrammarRuleStateTransitions> for ::windows::core::IUnknown {
fn from(value: &ISpeechGrammarRuleStateTransitions) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechGrammarRuleStateTransitions {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechGrammarRuleStateTransitions {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechGrammarRuleStateTransitions> for super::super::System::Com::IDispatch {
fn from(value: ISpeechGrammarRuleStateTransitions) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechGrammarRuleStateTransitions> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechGrammarRuleStateTransitions) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechGrammarRuleStateTransitions {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechGrammarRuleStateTransitions {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechGrammarRuleStateTransitions_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, transition: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechGrammarRules(pub ::windows::core::IUnknown);
impl ISpeechGrammarRules {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn FindRule<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, rulenameorid: Param0) -> ::windows::core::Result<ISpeechGrammarRule> {
let mut result__: <ISpeechGrammarRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), rulenameorid.into_param().abi(), &mut result__).from_abi::<ISpeechGrammarRule>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechGrammarRule> {
let mut result__: <ISpeechGrammarRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechGrammarRule>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
pub unsafe fn Dynamic(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Add<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, rulename: Param0, attributes: SpeechRuleAttributes, ruleid: i32) -> ::windows::core::Result<ISpeechGrammarRule> {
let mut result__: <ISpeechGrammarRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), rulename.into_param().abi(), ::core::mem::transmute(attributes), ::core::mem::transmute(ruleid), &mut result__).from_abi::<ISpeechGrammarRule>(result__)
}
pub unsafe fn Commit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CommitAndSave(&self, errortext: *mut super::super::Foundation::BSTR, savestream: *mut super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(errortext), ::core::mem::transmute(savestream)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechGrammarRules {
type Vtable = ISpeechGrammarRules_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6ffa3b44_fc2d_40d1_8afc_32911c7f1ad1);
}
impl ::core::convert::From<ISpeechGrammarRules> for ::windows::core::IUnknown {
fn from(value: ISpeechGrammarRules) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechGrammarRules> for ::windows::core::IUnknown {
fn from(value: &ISpeechGrammarRules) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechGrammarRules {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechGrammarRules {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechGrammarRules> for super::super::System::Com::IDispatch {
fn from(value: ISpeechGrammarRules) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechGrammarRules> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechGrammarRules) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechGrammarRules {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechGrammarRules {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechGrammarRules_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rulenameorid: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dynamic: *mut i16) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rulename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, attributes: SpeechRuleAttributes, ruleid: i32, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, errortext: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, savestream: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechLexicon(pub ::windows::core::IUnknown);
impl ISpeechLexicon {
pub unsafe fn GenerationId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn GetWords(&self, flags: SpeechLexiconType, generationid: *mut i32, words: *mut ::core::option::Option<ISpeechLexiconWords>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(flags), ::core::mem::transmute(generationid), ::core::mem::transmute(words)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn AddPronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrword: Param0, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), bstrword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(partofspeech), bstrpronunciation.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AddPronunciationByPhoneIds<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrword: Param0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), bstrword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(partofspeech), ::core::mem::transmute(phoneids)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemovePronunciation<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param3: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrword: Param0, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: Param3) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), bstrword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(partofspeech), bstrpronunciation.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn RemovePronunciationByPhoneIds<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrword: Param0, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), bstrword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(partofspeech), ::core::mem::transmute(phoneids)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPronunciations<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrword: Param0, langid: i32, typeflags: SpeechLexiconType) -> ::windows::core::Result<ISpeechLexiconPronunciations> {
let mut result__: <ISpeechLexiconPronunciations as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), bstrword.into_param().abi(), ::core::mem::transmute(langid), ::core::mem::transmute(typeflags), &mut result__).from_abi::<ISpeechLexiconPronunciations>(result__)
}
pub unsafe fn GetGenerationChange(&self, generationid: *mut i32, ppwords: *mut ::core::option::Option<ISpeechLexiconWords>) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(generationid), ::core::mem::transmute(ppwords)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechLexicon {
type Vtable = ISpeechLexicon_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3da7627a_c7ae_4b23_8708_638c50362c25);
}
impl ::core::convert::From<ISpeechLexicon> for ::windows::core::IUnknown {
fn from(value: ISpeechLexicon) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechLexicon> for ::windows::core::IUnknown {
fn from(value: &ISpeechLexicon) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechLexicon {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechLexicon> for super::super::System::Com::IDispatch {
fn from(value: ISpeechLexicon) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechLexicon> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechLexicon) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechLexicon {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechLexicon {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechLexicon_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, generationid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, flags: SpeechLexiconType, generationid: *mut i32, words: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrword: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrword: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrword: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, bstrpronunciation: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrword: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, langid: i32, partofspeech: SpeechPartOfSpeech, phoneids: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrword: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, langid: i32, typeflags: SpeechLexiconType, pppronunciations: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, generationid: *mut i32, ppwords: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechLexiconPronunciation(pub ::windows::core::IUnknown);
impl ISpeechLexiconPronunciation {
pub unsafe fn Type(&self) -> ::windows::core::Result<SpeechLexiconType> {
let mut result__: <SpeechLexiconType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechLexiconType>(result__)
}
pub unsafe fn LangId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn PartOfSpeech(&self) -> ::windows::core::Result<SpeechPartOfSpeech> {
let mut result__: <SpeechPartOfSpeech as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechPartOfSpeech>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn PhoneIds(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Symbolic(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechLexiconPronunciation {
type Vtable = ISpeechLexiconPronunciation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x95252c5d_9e43_4f4a_9899_48ee73352f9f);
}
impl ::core::convert::From<ISpeechLexiconPronunciation> for ::windows::core::IUnknown {
fn from(value: ISpeechLexiconPronunciation) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechLexiconPronunciation> for ::windows::core::IUnknown {
fn from(value: &ISpeechLexiconPronunciation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechLexiconPronunciation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechLexiconPronunciation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechLexiconPronunciation> for super::super::System::Com::IDispatch {
fn from(value: ISpeechLexiconPronunciation) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechLexiconPronunciation> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechLexiconPronunciation) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechLexiconPronunciation {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechLexiconPronunciation {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechLexiconPronunciation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lexicontype: *mut SpeechLexiconType) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, langid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, partofspeech: *mut SpeechPartOfSpeech) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phoneids: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, symbolic: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechLexiconPronunciations(pub ::windows::core::IUnknown);
impl ISpeechLexiconPronunciations {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechLexiconPronunciation> {
let mut result__: <ISpeechLexiconPronunciation as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechLexiconPronunciation>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechLexiconPronunciations {
type Vtable = ISpeechLexiconPronunciations_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x72829128_5682_4704_a0d4_3e2bb6f2ead3);
}
impl ::core::convert::From<ISpeechLexiconPronunciations> for ::windows::core::IUnknown {
fn from(value: ISpeechLexiconPronunciations) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechLexiconPronunciations> for ::windows::core::IUnknown {
fn from(value: &ISpeechLexiconPronunciations) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechLexiconPronunciations {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechLexiconPronunciations {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechLexiconPronunciations> for super::super::System::Com::IDispatch {
fn from(value: ISpeechLexiconPronunciations) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechLexiconPronunciations> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechLexiconPronunciations) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechLexiconPronunciations {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechLexiconPronunciations {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechLexiconPronunciations_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, pronunciation: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechLexiconWord(pub ::windows::core::IUnknown);
impl ISpeechLexiconWord {
pub unsafe fn LangId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Type(&self) -> ::windows::core::Result<SpeechWordType> {
let mut result__: <SpeechWordType as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechWordType>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Word(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Pronunciations(&self) -> ::windows::core::Result<ISpeechLexiconPronunciations> {
let mut result__: <ISpeechLexiconPronunciations as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechLexiconPronunciations>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechLexiconWord {
type Vtable = ISpeechLexiconWord_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4e5b933c_c9be_48ed_8842_1ee51bb1d4ff);
}
impl ::core::convert::From<ISpeechLexiconWord> for ::windows::core::IUnknown {
fn from(value: ISpeechLexiconWord) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechLexiconWord> for ::windows::core::IUnknown {
fn from(value: &ISpeechLexiconWord) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechLexiconWord {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechLexiconWord {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechLexiconWord> for super::super::System::Com::IDispatch {
fn from(value: ISpeechLexiconWord) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechLexiconWord> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechLexiconWord) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechLexiconWord {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechLexiconWord {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechLexiconWord_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, langid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, wordtype: *mut SpeechWordType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, word: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pronunciations: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechLexiconWords(pub ::windows::core::IUnknown);
impl ISpeechLexiconWords {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechLexiconWord> {
let mut result__: <ISpeechLexiconWord as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechLexiconWord>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechLexiconWords {
type Vtable = ISpeechLexiconWords_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8d199862_415e_47d5_ac4f_faa608b424e6);
}
impl ::core::convert::From<ISpeechLexiconWords> for ::windows::core::IUnknown {
fn from(value: ISpeechLexiconWords) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechLexiconWords> for ::windows::core::IUnknown {
fn from(value: &ISpeechLexiconWords) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechLexiconWords {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechLexiconWords {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechLexiconWords> for super::super::System::Com::IDispatch {
fn from(value: ISpeechLexiconWords) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechLexiconWords> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechLexiconWords) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechLexiconWords {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechLexiconWords {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechLexiconWords_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, word: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechMMSysAudio(pub ::windows::core::IUnknown);
impl ISpeechMMSysAudio {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn Status(&self) -> ::windows::core::Result<ISpeechAudioStatus> {
let mut result__: <ISpeechAudioStatus as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioStatus>(result__)
}
pub unsafe fn BufferInfo(&self) -> ::windows::core::Result<ISpeechAudioBufferInfo> {
let mut result__: <ISpeechAudioBufferInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioBufferInfo>(result__)
}
pub unsafe fn DefaultFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn Volume(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetVolume(&self, volume: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
pub unsafe fn BufferNotifySize(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetBufferNotifySize(&self, buffernotifysize: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffernotifysize)).ok()
}
pub unsafe fn EventHandle(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetState(&self, state: SpeechAudioState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
pub unsafe fn DeviceId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetDeviceId(&self, deviceid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(deviceid)).ok()
}
pub unsafe fn LineId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetLineId(&self, lineid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(lineid)).ok()
}
pub unsafe fn MMHandle(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechMMSysAudio {
type Vtable = ISpeechMMSysAudio_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3c76af6d_1fd7_4831_81d1_3b71d5a13c44);
}
impl ::core::convert::From<ISpeechMMSysAudio> for ::windows::core::IUnknown {
fn from(value: ISpeechMMSysAudio) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechMMSysAudio> for ::windows::core::IUnknown {
fn from(value: &ISpeechMMSysAudio) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechMMSysAudio> for ISpeechAudio {
fn from(value: ISpeechMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechMMSysAudio> for ISpeechAudio {
fn from(value: &ISpeechMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechAudio> for ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechAudio> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechAudio> for &ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechAudio> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
impl ::core::convert::From<ISpeechMMSysAudio> for ISpeechBaseStream {
fn from(value: ISpeechMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechMMSysAudio> for ISpeechBaseStream {
fn from(value: &ISpeechMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for &ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechMMSysAudio> for super::super::System::Com::IDispatch {
fn from(value: ISpeechMMSysAudio) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechMMSysAudio> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechMMSysAudio) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechMMSysAudio {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechMMSysAudio_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bufferinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffernotifysize: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffernotifysize: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventhandle: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechAudioState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, deviceid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, deviceid: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lineid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lineid: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechMemoryStream(pub ::windows::core::IUnknown);
impl ISpeechMemoryStream {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn Format(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn putref_Format<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, audioformat: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), audioformat.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Read(&self, buffer: *mut super::super::System::Com::VARIANT, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(buffer), ::core::mem::transmute(numberofbytes), ::core::mem::transmute(bytesread)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Write<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, buffer: Param0) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), buffer.into_param().abi(), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Seek<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, position: Param0, origin: SpeechStreamSeekPositionType) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), position.into_param().abi(), ::core::mem::transmute(origin), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetData<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, data: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), data.into_param().abi()).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GetData(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechMemoryStream {
type Vtable = ISpeechMemoryStream_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xeeb14b68_808b_4abe_a5ea_b51da7588008);
}
impl ::core::convert::From<ISpeechMemoryStream> for ::windows::core::IUnknown {
fn from(value: ISpeechMemoryStream) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechMemoryStream> for ::windows::core::IUnknown {
fn from(value: &ISpeechMemoryStream) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechMemoryStream> for ISpeechBaseStream {
fn from(value: ISpeechMemoryStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechMemoryStream> for ISpeechBaseStream {
fn from(value: &ISpeechMemoryStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechBaseStream> for &ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechBaseStream> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechMemoryStream> for super::super::System::Com::IDispatch {
fn from(value: ISpeechMemoryStream) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechMemoryStream> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechMemoryStream) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechMemoryStream {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechMemoryStream_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioformat: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, numberofbytes: i32, bytesread: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, buffer: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, byteswritten: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, origin: SpeechStreamSeekPositionType, newposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, data: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pdata: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechObjectToken(pub ::windows::core::IUnknown);
impl ISpeechObjectToken {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Id(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn DataKey(&self) -> ::windows::core::Result<ISpeechDataKey> {
let mut result__: <ISpeechDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechDataKey>(result__)
}
pub unsafe fn Category(&self) -> ::windows::core::Result<ISpeechObjectTokenCategory> {
let mut result__: <ISpeechObjectTokenCategory as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectTokenCategory>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetDescription(&self, locale: i32) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(locale), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, id: Param0, categoryid: Param1, createifnotexist: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), id.into_param().abi(), categoryid.into_param().abi(), ::core::mem::transmute(createifnotexist)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAttribute<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, attributename: Param0) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), attributename.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn CreateInstance<'a, Param0: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, punkouter: Param0, clscontext: SpeechTokenContext) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), punkouter.into_param().abi(), ::core::mem::transmute(clscontext), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Remove<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, objectstorageclsid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), objectstorageclsid.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetStorageFileName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, objectstorageclsid: Param0, keyname: Param1, filename: Param2, folder: SpeechTokenShellFolder) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), objectstorageclsid.into_param().abi(), keyname.into_param().abi(), filename.into_param().abi(), ::core::mem::transmute(folder), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RemoveStorageFileName<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, objectstorageclsid: Param0, keyname: Param1, deletefilea: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), objectstorageclsid.into_param().abi(), keyname.into_param().abi(), ::core::mem::transmute(deletefilea)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, typeofui: Param0, extradata: *const super::super::System::Com::VARIANT, object: Param2) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), object.into_param().abi(), &mut result__).from_abi::<i16>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn DisplayUI<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param4: ::windows::core::IntoParam<'a, ::windows::core::IUnknown>>(&self, hwnd: i32, title: Param1, typeofui: Param2, extradata: *const super::super::System::Com::VARIANT, object: Param4) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(hwnd), title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata), object.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn MatchesAttributes<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, attributes: Param0) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), attributes.into_param().abi(), &mut result__).from_abi::<i16>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechObjectToken {
type Vtable = ISpeechObjectToken_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc74a3adc_b727_4500_a84a_b526721c8b8c);
}
impl ::core::convert::From<ISpeechObjectToken> for ::windows::core::IUnknown {
fn from(value: ISpeechObjectToken) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechObjectToken> for ::windows::core::IUnknown {
fn from(value: &ISpeechObjectToken) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechObjectToken> for super::super::System::Com::IDispatch {
fn from(value: ISpeechObjectToken) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechObjectToken> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechObjectToken) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechObjectToken {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechObjectToken_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, datakey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, category: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, locale: i32, description: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, categoryid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, createifnotexist: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, attributename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, attributevalue: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, punkouter: ::windows::core::RawPtr, clscontext: SpeechTokenContext, object: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectstorageclsid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectstorageclsid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, keyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, filename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, folder: SpeechTokenShellFolder, filepath: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, objectstorageclsid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, keyname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, deletefilea: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, object: ::windows::core::RawPtr, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwnd: i32, title: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, object: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, attributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, matches: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechObjectTokenCategory(pub ::windows::core::IUnknown);
impl ISpeechObjectTokenCategory {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Id(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetDefault<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, tokenid: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), tokenid.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Default(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, id: Param0, createifnotexist: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), id.into_param().abi(), ::core::mem::transmute(createifnotexist)).ok()
}
pub unsafe fn GetDataKey(&self, location: SpeechDataKeyLocation) -> ::windows::core::Result<ISpeechDataKey> {
let mut result__: <ISpeechDataKey as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(location), &mut result__).from_abi::<ISpeechDataKey>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EnumerateTokens<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechObjectTokenCategory {
type Vtable = ISpeechObjectTokenCategory_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xca7eac50_2d01_4145_86d4_5ae7d70f4469);
}
impl ::core::convert::From<ISpeechObjectTokenCategory> for ::windows::core::IUnknown {
fn from(value: ISpeechObjectTokenCategory) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechObjectTokenCategory> for ::windows::core::IUnknown {
fn from(value: &ISpeechObjectTokenCategory) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechObjectTokenCategory> for super::super::System::Com::IDispatch {
fn from(value: ISpeechObjectTokenCategory) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechObjectTokenCategory> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechObjectTokenCategory) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechObjectTokenCategory {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechObjectTokenCategory_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tokenid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tokenid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, createifnotexist: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, location: SpeechDataKeyLocation, datakey: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, tokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechObjectTokens(pub ::windows::core::IUnknown);
impl ISpeechObjectTokens {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechObjectTokens {
type Vtable = ISpeechObjectTokens_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9285b776_2e7b_4bc0_b53e_580eb6fa967f);
}
impl ::core::convert::From<ISpeechObjectTokens> for ::windows::core::IUnknown {
fn from(value: ISpeechObjectTokens) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechObjectTokens> for ::windows::core::IUnknown {
fn from(value: &ISpeechObjectTokens) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechObjectTokens> for super::super::System::Com::IDispatch {
fn from(value: ISpeechObjectTokens) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechObjectTokens> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechObjectTokens) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechObjectTokens {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechObjectTokens_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, token: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ppenumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhoneConverter(pub ::windows::core::IUnknown);
impl ISpeechPhoneConverter {
pub unsafe fn LanguageId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetLanguageId(&self, languageid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(languageid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn PhoneToId<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, phonemes: Param0) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), phonemes.into_param().abi(), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn IdToPhone<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, idarray: Param0) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), idarray.into_param().abi(), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhoneConverter {
type Vtable = ISpeechPhoneConverter_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc3e4f353_433f_43d6_89a1_6a62a7054c3d);
}
impl ::core::convert::From<ISpeechPhoneConverter> for ::windows::core::IUnknown {
fn from(value: ISpeechPhoneConverter) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhoneConverter> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhoneConverter) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhoneConverter> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhoneConverter) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhoneConverter> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhoneConverter) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhoneConverter {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhoneConverter_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, languageid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, languageid: i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phonemes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, idarray: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, idarray: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, phonemes: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseAlternate(pub ::windows::core::IUnknown);
impl ISpeechPhraseAlternate {
pub unsafe fn RecoResult(&self) -> ::windows::core::Result<ISpeechRecoResult> {
let mut result__: <ISpeechRecoResult as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoResult>(result__)
}
pub unsafe fn StartElementInResult(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NumberOfElementsInResult(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn PhraseInfo(&self) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
pub unsafe fn Commit(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseAlternate {
type Vtable = ISpeechPhraseAlternate_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x27864a2a_2b9f_4cb8_92d3_0d2722fd1e73);
}
impl ::core::convert::From<ISpeechPhraseAlternate> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseAlternate) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseAlternate> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseAlternate) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseAlternate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseAlternate {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseAlternate> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseAlternate) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseAlternate> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseAlternate) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseAlternate {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseAlternate {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseAlternate_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recoresult: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numberofelements: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseAlternates(pub ::windows::core::IUnknown);
impl ISpeechPhraseAlternates {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechPhraseAlternate> {
let mut result__: <ISpeechPhraseAlternate as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechPhraseAlternate>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseAlternates {
type Vtable = ISpeechPhraseAlternates_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb238b6d5_f276_4c3d_a6c1_2974801c3cc2);
}
impl ::core::convert::From<ISpeechPhraseAlternates> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseAlternates) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseAlternates> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseAlternates) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseAlternates {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseAlternates {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseAlternates> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseAlternates) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseAlternates> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseAlternates) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseAlternates {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseAlternates {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseAlternates_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, phrasealternate: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseElement(pub ::windows::core::IUnknown);
impl ISpeechPhraseElement {
pub unsafe fn AudioTimeOffset(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn AudioSizeTime(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn AudioStreamOffset(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn AudioSizeBytes(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn RetainedStreamOffset(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn RetainedSizeBytes(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DisplayText(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LexicalForm(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Pronunciation(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn DisplayAttributes(&self) -> ::windows::core::Result<SpeechDisplayAttributes> {
let mut result__: <SpeechDisplayAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechDisplayAttributes>(result__)
}
pub unsafe fn RequiredConfidence(&self) -> ::windows::core::Result<SpeechEngineConfidence> {
let mut result__: <SpeechEngineConfidence as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechEngineConfidence>(result__)
}
pub unsafe fn ActualConfidence(&self) -> ::windows::core::Result<SpeechEngineConfidence> {
let mut result__: <SpeechEngineConfidence as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechEngineConfidence>(result__)
}
pub unsafe fn EngineConfidence(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseElement {
type Vtable = ISpeechPhraseElement_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe6176f96_e373_4801_b223_3b62c068c0b4);
}
impl ::core::convert::From<ISpeechPhraseElement> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseElement) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseElement> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseElement) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseElement {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseElement {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseElement> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseElement) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseElement> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseElement) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseElement {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseElement {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseElement_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiotimeoffset: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiosizetime: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiostreamoffset: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiosizebytes: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, retainedstreamoffset: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, retainedsizebytes: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, displaytext: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, lexicalform: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pronunciation: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, displayattributes: *mut SpeechDisplayAttributes) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredconfidence: *mut SpeechEngineConfidence) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, actualconfidence: *mut SpeechEngineConfidence) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, engineconfidence: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseElements(pub ::windows::core::IUnknown);
impl ISpeechPhraseElements {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechPhraseElement> {
let mut result__: <ISpeechPhraseElement as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechPhraseElement>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseElements {
type Vtable = ISpeechPhraseElements_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0626b328_3478_467d_a0b3_d0853b93dda3);
}
impl ::core::convert::From<ISpeechPhraseElements> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseElements) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseElements> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseElements) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseElements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseElements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseElements> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseElements) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseElements> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseElements) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseElements {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseElements {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseElements_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, element: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseInfo(pub ::windows::core::IUnknown);
impl ISpeechPhraseInfo {
pub unsafe fn LanguageId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn GrammarId(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn StartTime(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn AudioStreamPosition(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn AudioSizeBytes(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn RetainedSizeBytes(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn AudioSizeTime(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Rule(&self) -> ::windows::core::Result<ISpeechPhraseRule> {
let mut result__: <ISpeechPhraseRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseRule>(result__)
}
pub unsafe fn Properties(&self) -> ::windows::core::Result<ISpeechPhraseProperties> {
let mut result__: <ISpeechPhraseProperties as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseProperties>(result__)
}
pub unsafe fn Elements(&self) -> ::windows::core::Result<ISpeechPhraseElements> {
let mut result__: <ISpeechPhraseElements as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseElements>(result__)
}
pub unsafe fn Replacements(&self) -> ::windows::core::Result<ISpeechPhraseReplacements> {
let mut result__: <ISpeechPhraseReplacements as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseReplacements>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn EngineId(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn EnginePrivateData(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SaveToMemory(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetText(&self, startelement: i32, elements: i32, usereplacements: i16) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(usereplacements), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn GetDisplayAttributes(&self, startelement: i32, elements: i32, usereplacements: i16) -> ::windows::core::Result<SpeechDisplayAttributes> {
let mut result__: <SpeechDisplayAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(usereplacements), &mut result__).from_abi::<SpeechDisplayAttributes>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseInfo {
type Vtable = ISpeechPhraseInfo_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x961559cf_4e67_4662_8bf0_d93f1fcd61b3);
}
impl ::core::convert::From<ISpeechPhraseInfo> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseInfo) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseInfo> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseInfo) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseInfo {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseInfo> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseInfo) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseInfo> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseInfo) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseInfo {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseInfo {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseInfo_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, languageid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grammarid: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, starttime: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiostreamposition: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, paudiosizebytes: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, retainedsizebytes: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiosizetime: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, properties: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, elements: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, replacements: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, engineidguid: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, privatedata: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseblock: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, usereplacements: i16, text: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, usereplacements: i16, displayattributes: *mut SpeechDisplayAttributes) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseInfoBuilder(pub ::windows::core::IUnknown);
impl ISpeechPhraseInfoBuilder {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn RestorePhraseFromMemory(&self, phraseinmemory: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(phraseinmemory), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseInfoBuilder {
type Vtable = ISpeechPhraseInfoBuilder_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3b151836_df3a_4e0a_846c_d2adc9334333);
}
impl ::core::convert::From<ISpeechPhraseInfoBuilder> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseInfoBuilder) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseInfoBuilder> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseInfoBuilder) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseInfoBuilder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseInfoBuilder {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseInfoBuilder> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseInfoBuilder) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseInfoBuilder> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseInfoBuilder) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseInfoBuilder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseInfoBuilder {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseInfoBuilder_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinmemory: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseProperties(pub ::windows::core::IUnknown);
impl ISpeechPhraseProperties {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechPhraseProperty> {
let mut result__: <ISpeechPhraseProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechPhraseProperty>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseProperties {
type Vtable = ISpeechPhraseProperties_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x08166b47_102e_4b23_a599_bdb98dbfd1f4);
}
impl ::core::convert::From<ISpeechPhraseProperties> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseProperties) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseProperties> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseProperties) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseProperties {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseProperties {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseProperties> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseProperties) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseProperties> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseProperties) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseProperties {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseProperties {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseProperties_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, property: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseProperty(pub ::windows::core::IUnknown);
impl ISpeechPhraseProperty {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Name(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Id(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Value(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn FirstElement(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NumberOfElements(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn EngineConfidence(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
pub unsafe fn Confidence(&self) -> ::windows::core::Result<SpeechEngineConfidence> {
let mut result__: <SpeechEngineConfidence as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechEngineConfidence>(result__)
}
pub unsafe fn Parent(&self) -> ::windows::core::Result<ISpeechPhraseProperty> {
let mut result__: <ISpeechPhraseProperty as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseProperty>(result__)
}
pub unsafe fn Children(&self) -> ::windows::core::Result<ISpeechPhraseProperties> {
let mut result__: <ISpeechPhraseProperties as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseProperties>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseProperty {
type Vtable = ISpeechPhraseProperty_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xce563d48_961e_4732_a2e1_378a42b430be);
}
impl ::core::convert::From<ISpeechPhraseProperty> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseProperty) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseProperty> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseProperty) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseProperty {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseProperty> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseProperty) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseProperty> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseProperty) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseProperty {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseProperty {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseProperty_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, value: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, firstelement: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numberofelements: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, confidence: *mut f32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, confidence: *mut SpeechEngineConfidence) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parentproperty: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, children: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseReplacement(pub ::windows::core::IUnknown);
impl ISpeechPhraseReplacement {
pub unsafe fn DisplayAttributes(&self) -> ::windows::core::Result<SpeechDisplayAttributes> {
let mut result__: <SpeechDisplayAttributes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechDisplayAttributes>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Text(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn FirstElement(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NumberOfElements(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseReplacement {
type Vtable = ISpeechPhraseReplacement_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2890a410_53a7_4fb5_94ec_06d4998e3d02);
}
impl ::core::convert::From<ISpeechPhraseReplacement> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseReplacement) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseReplacement> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseReplacement) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseReplacement {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseReplacement {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseReplacement> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseReplacement) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseReplacement> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseReplacement) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseReplacement {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseReplacement {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseReplacement_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, displayattributes: *mut SpeechDisplayAttributes) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, text: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, firstelement: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numberofelements: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseReplacements(pub ::windows::core::IUnknown);
impl ISpeechPhraseReplacements {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechPhraseReplacement> {
let mut result__: <ISpeechPhraseReplacement as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechPhraseReplacement>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseReplacements {
type Vtable = ISpeechPhraseReplacements_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x38bc662f_2257_4525_959e_2069d2596c05);
}
impl ::core::convert::From<ISpeechPhraseReplacements> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseReplacements) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseReplacements> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseReplacements) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseReplacements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseReplacements {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseReplacements> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseReplacements) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseReplacements> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseReplacements) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseReplacements {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseReplacements {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseReplacements_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, reps: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseRule(pub ::windows::core::IUnknown);
impl ISpeechPhraseRule {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Name(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn Id(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn FirstElement(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NumberOfElements(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Parent(&self) -> ::windows::core::Result<ISpeechPhraseRule> {
let mut result__: <ISpeechPhraseRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseRule>(result__)
}
pub unsafe fn Children(&self) -> ::windows::core::Result<ISpeechPhraseRules> {
let mut result__: <ISpeechPhraseRules as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseRules>(result__)
}
pub unsafe fn Confidence(&self) -> ::windows::core::Result<SpeechEngineConfidence> {
let mut result__: <SpeechEngineConfidence as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechEngineConfidence>(result__)
}
pub unsafe fn EngineConfidence(&self) -> ::windows::core::Result<f32> {
let mut result__: <f32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<f32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseRule {
type Vtable = ISpeechPhraseRule_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa7bfe112_a4a0_48d9_b602_c313843f6964);
}
impl ::core::convert::From<ISpeechPhraseRule> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseRule) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseRule> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseRule) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseRule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseRule {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseRule> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseRule) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseRule> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseRule) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseRule {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseRule {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseRule_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, firstelement: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numberofelements: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, parent: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, children: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, actualconfidence: *mut SpeechEngineConfidence) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, engineconfidence: *mut f32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechPhraseRules(pub ::windows::core::IUnknown);
impl ISpeechPhraseRules {
pub unsafe fn Count(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Item(&self, index: i32) -> ::windows::core::Result<ISpeechPhraseRule> {
let mut result__: <ISpeechPhraseRule as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(index), &mut result__).from_abi::<ISpeechPhraseRule>(result__)
}
pub unsafe fn _NewEnum(&self) -> ::windows::core::Result<::windows::core::IUnknown> {
let mut result__: <::windows::core::IUnknown as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<::windows::core::IUnknown>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechPhraseRules {
type Vtable = ISpeechPhraseRules_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9047d593_01dd_4b72_81a3_e4a0ca69f407);
}
impl ::core::convert::From<ISpeechPhraseRules> for ::windows::core::IUnknown {
fn from(value: ISpeechPhraseRules) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechPhraseRules> for ::windows::core::IUnknown {
fn from(value: &ISpeechPhraseRules) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechPhraseRules {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechPhraseRules {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechPhraseRules> for super::super::System::Com::IDispatch {
fn from(value: ISpeechPhraseRules) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechPhraseRules> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechPhraseRules) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechPhraseRules {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechPhraseRules {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechPhraseRules_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, count: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, index: i32, rule: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, enumvariant: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoContext(pub ::windows::core::IUnknown);
impl ISpeechRecoContext {
pub unsafe fn Recognizer(&self) -> ::windows::core::Result<ISpeechRecognizer> {
let mut result__: <ISpeechRecognizer as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecognizer>(result__)
}
pub unsafe fn AudioInputInterferenceStatus(&self) -> ::windows::core::Result<SpeechInterference> {
let mut result__: <SpeechInterference as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechInterference>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn RequestedUIType(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn putref_Voice<'a, Param0: ::windows::core::IntoParam<'a, ISpeechVoice>>(&self, voice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), voice.into_param().abi()).ok()
}
pub unsafe fn Voice(&self) -> ::windows::core::Result<ISpeechVoice> {
let mut result__: <ISpeechVoice as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechVoice>(result__)
}
pub unsafe fn SetAllowVoiceFormatMatchingOnNextSet(&self, allow: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(allow)).ok()
}
pub unsafe fn AllowVoiceFormatMatchingOnNextSet(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetVoicePurgeEvent(&self, eventinterest: SpeechRecoEvents) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventinterest)).ok()
}
pub unsafe fn VoicePurgeEvent(&self) -> ::windows::core::Result<SpeechRecoEvents> {
let mut result__: <SpeechRecoEvents as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRecoEvents>(result__)
}
pub unsafe fn SetEventInterests(&self, eventinterest: SpeechRecoEvents) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventinterest)).ok()
}
pub unsafe fn EventInterests(&self) -> ::windows::core::Result<SpeechRecoEvents> {
let mut result__: <SpeechRecoEvents as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRecoEvents>(result__)
}
pub unsafe fn SetCmdMaxAlternates(&self, maxalternates: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(maxalternates)).ok()
}
pub unsafe fn CmdMaxAlternates(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetState(&self, state: SpeechRecoContextState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
pub unsafe fn State(&self) -> ::windows::core::Result<SpeechRecoContextState> {
let mut result__: <SpeechRecoContextState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRecoContextState>(result__)
}
pub unsafe fn SetRetainedAudio(&self, option: SpeechRetainedAudioOptions) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(option)).ok()
}
pub unsafe fn RetainedAudio(&self) -> ::windows::core::Result<SpeechRetainedAudioOptions> {
let mut result__: <SpeechRetainedAudioOptions as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRetainedAudioOptions>(result__)
}
pub unsafe fn putref_RetainedAudioFormat<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, format: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), format.into_param().abi()).ok()
}
pub unsafe fn RetainedAudioFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateGrammar<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, grammarid: Param0) -> ::windows::core::Result<ISpeechRecoGrammar> {
let mut result__: <ISpeechRecoGrammar as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), grammarid.into_param().abi(), &mut result__).from_abi::<ISpeechRecoGrammar>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CreateResultFromMemory(&self, resultblock: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<ISpeechRecoResult> {
let mut result__: <ISpeechRecoResult as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(resultblock), &mut result__).from_abi::<ISpeechRecoResult>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Bookmark<'a, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>, Param2: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, options: SpeechBookmarkOptions, streampos: Param1, bookmarkid: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), ::core::mem::transmute(options), streampos.into_param().abi(), bookmarkid.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetAdaptationData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, adaptationstring: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), adaptationstring.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoContext {
type Vtable = ISpeechRecoContext_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x580aa49d_7e1e_4809_b8e2_57da806104b8);
}
impl ::core::convert::From<ISpeechRecoContext> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoContext) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoContext> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoContext) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoContext> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoContext) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoContext> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoContext) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoContext {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoContext_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recognizer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, interference: *mut SpeechInterference) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, uitype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, voice: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, voice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allow: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pallow: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterest: SpeechRecoEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterest: *mut SpeechRecoEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterest: SpeechRecoEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterest: *mut SpeechRecoEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, maxalternates: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, maxalternates: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechRecoContextState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut SpeechRecoContextState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, option: SpeechRetainedAudioOptions) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, option: *mut SpeechRetainedAudioOptions) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grammarid: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, grammar: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resultblock: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, result: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: SpeechBookmarkOptions, streampos: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, bookmarkid: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, adaptationstring: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoGrammar(pub ::windows::core::IUnknown);
impl ISpeechRecoGrammar {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Id(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn RecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn SetState(&self, state: SpeechGrammarState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
pub unsafe fn State(&self) -> ::windows::core::Result<SpeechGrammarState> {
let mut result__: <SpeechGrammarState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechGrammarState>(result__)
}
pub unsafe fn Rules(&self) -> ::windows::core::Result<ISpeechGrammarRules> {
let mut result__: <ISpeechGrammarRules as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechGrammarRules>(result__)
}
pub unsafe fn Reset(&self, newlanguage: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(newlanguage)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CmdLoadFromFile<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, filename: Param0, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), filename.into_param().abi(), ::core::mem::transmute(loadoption)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CmdLoadFromObject<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, classid: Param0, grammarname: Param1, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), classid.into_param().abi(), grammarname.into_param().abi(), ::core::mem::transmute(loadoption)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CmdLoadFromResource<'a, Param1: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>, Param2: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, hmodule: i32, resourcename: Param1, resourcetype: Param2, languageid: i32, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(hmodule), resourcename.into_param().abi(), resourcetype.into_param().abi(), ::core::mem::transmute(languageid), ::core::mem::transmute(loadoption)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CmdLoadFromMemory<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, grammardata: Param0, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), grammardata.into_param().abi(), ::core::mem::transmute(loadoption)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CmdLoadFromProprietaryGrammar<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, proprietaryguid: Param0, proprietarystring: Param1, proprietarydata: Param2, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), proprietaryguid.into_param().abi(), proprietarystring.into_param().abi(), proprietarydata.into_param().abi(), ::core::mem::transmute(loadoption)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn CmdSetRuleState<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, name: Param0, state: SpeechRuleState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(state)).ok()
}
pub unsafe fn CmdSetRuleIdState(&self, ruleid: i32, state: SpeechRuleState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), ::core::mem::transmute(ruleid), ::core::mem::transmute(state)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn DictationLoad<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, topicname: Param0, loadoption: SpeechLoadOption) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), topicname.into_param().abi(), ::core::mem::transmute(loadoption)).ok()
}
pub unsafe fn DictationUnload(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn DictationSetState(&self, state: SpeechRuleState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetWordSequenceData<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, ISpeechTextSelectionInformation>>(&self, text: Param0, textlength: i32, info: Param2) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), text.into_param().abi(), ::core::mem::transmute(textlength), info.into_param().abi()).ok()
}
pub unsafe fn SetTextSelection<'a, Param0: ::windows::core::IntoParam<'a, ISpeechTextSelectionInformation>>(&self, info: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), info.into_param().abi()).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn IsPronounceable<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, word: Param0) -> ::windows::core::Result<SpeechWordPronounceable> {
let mut result__: <SpeechWordPronounceable as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), word.into_param().abi(), &mut result__).from_abi::<SpeechWordPronounceable>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoGrammar {
type Vtable = ISpeechRecoGrammar_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb6d6f79f_2158_4e50_b5bc_9a9ccd852a09);
}
impl ::core::convert::From<ISpeechRecoGrammar> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoGrammar) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoGrammar> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoGrammar) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoGrammar> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoGrammar) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoGrammar> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoGrammar) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoGrammar {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoGrammar_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, id: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechGrammarState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut SpeechGrammarState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rules: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newlanguage: i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, filename: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, classid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, grammarname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hmodule: i32, resourcename: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, resourcetype: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, languageid: i32, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, grammardata: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, proprietaryguid: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, proprietarystring: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, proprietarydata: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, state: SpeechRuleState) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, ruleid: i32, state: SpeechRuleState) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, topicname: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, loadoption: SpeechLoadOption) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechRuleState) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, text: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, textlength: i32, info: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, info: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, word: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, wordpronounceable: *mut SpeechWordPronounceable) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoResult(pub ::windows::core::IUnknown);
impl ISpeechRecoResult {
pub unsafe fn RecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn Times(&self) -> ::windows::core::Result<ISpeechRecoResultTimes> {
let mut result__: <ISpeechRecoResultTimes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoResultTimes>(result__)
}
pub unsafe fn putref_AudioFormat<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, format: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), format.into_param().abi()).ok()
}
pub unsafe fn AudioFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn PhraseInfo(&self) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
pub unsafe fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechPhraseAlternates> {
let mut result__: <ISpeechPhraseAlternates as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(requestcount), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechPhraseAlternates>(result__)
}
pub unsafe fn Audio(&self, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechMemoryStream> {
let mut result__: <ISpeechMemoryStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechMemoryStream>(result__)
}
pub unsafe fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SaveToMemory(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(valuetypes)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoResult {
type Vtable = ISpeechRecoResult_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xed2879cf_ced9_4ee6_a534_de0191d5468d);
}
impl ::core::convert::From<ISpeechRecoResult> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoResult) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoResult> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoResult) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoResult> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoResult> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoResult_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, times: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requestcount: i32, startelement: i32, elements: i32, alternates: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, stream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resultblock: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuetypes: SpeechDiscardType) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoResult2(pub ::windows::core::IUnknown);
impl ISpeechRecoResult2 {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn RecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn Times(&self) -> ::windows::core::Result<ISpeechRecoResultTimes> {
let mut result__: <ISpeechRecoResultTimes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoResultTimes>(result__)
}
pub unsafe fn putref_AudioFormat<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, format: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), format.into_param().abi()).ok()
}
pub unsafe fn AudioFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn PhraseInfo(&self) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
pub unsafe fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechPhraseAlternates> {
let mut result__: <ISpeechPhraseAlternates as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(requestcount), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechPhraseAlternates>(result__)
}
pub unsafe fn Audio(&self, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechMemoryStream> {
let mut result__: <ISpeechMemoryStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechMemoryStream>(result__)
}
pub unsafe fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SaveToMemory(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(valuetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextFeedback<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feedback: Param0, wassuccessful: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), feedback.into_param().abi(), ::core::mem::transmute(wassuccessful)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoResult2 {
type Vtable = ISpeechRecoResult2_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8e0a246d_d3c8_45de_8657_04290c458c3c);
}
impl ::core::convert::From<ISpeechRecoResult2> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoResult2) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoResult2> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoResult2) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechRecoResult2> for ISpeechRecoResult {
fn from(value: ISpeechRecoResult2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechRecoResult2> for ISpeechRecoResult {
fn from(value: &ISpeechRecoResult2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechRecoResult> for ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechRecoResult> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechRecoResult> for &ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechRecoResult> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoResult2> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoResult2) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoResult2> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoResult2) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoResult2 {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoResult2_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, times: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requestcount: i32, startelement: i32, elements: i32, alternates: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, stream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resultblock: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuetypes: SpeechDiscardType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, feedback: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, wassuccessful: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoResultDispatch(pub ::windows::core::IUnknown);
impl ISpeechRecoResultDispatch {
pub unsafe fn RecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn Times(&self) -> ::windows::core::Result<ISpeechRecoResultTimes> {
let mut result__: <ISpeechRecoResultTimes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoResultTimes>(result__)
}
pub unsafe fn putref_AudioFormat<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, format: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), format.into_param().abi()).ok()
}
pub unsafe fn AudioFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn PhraseInfo(&self) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
pub unsafe fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechPhraseAlternates> {
let mut result__: <ISpeechPhraseAlternates as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(requestcount), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechPhraseAlternates>(result__)
}
pub unsafe fn Audio(&self, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechMemoryStream> {
let mut result__: <ISpeechMemoryStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechMemoryStream>(result__)
}
pub unsafe fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SaveToMemory(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(valuetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLResult(&self, options: SPXMLRESULTOPTIONS) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLErrorInfo(&self, linenumber: *mut i32, scriptline: *mut super::super::Foundation::BSTR, source: *mut super::super::Foundation::BSTR, description: *mut super::super::Foundation::BSTR, resultcode: *mut ::windows::core::HRESULT, iserror: *mut i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(linenumber), ::core::mem::transmute(scriptline), ::core::mem::transmute(source), ::core::mem::transmute(description), ::core::mem::transmute(resultcode), ::core::mem::transmute(iserror)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetTextFeedback<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, feedback: Param0, wassuccessful: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), feedback.into_param().abi(), ::core::mem::transmute(wassuccessful)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoResultDispatch {
type Vtable = ISpeechRecoResultDispatch_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x6d60eb64_aced_40a6_bbf3_4e557f71dee2);
}
impl ::core::convert::From<ISpeechRecoResultDispatch> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoResultDispatch) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoResultDispatch> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoResultDispatch) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoResultDispatch {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoResultDispatch {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoResultDispatch> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoResultDispatch) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoResultDispatch> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoResultDispatch) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoResultDispatch {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoResultDispatch {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoResultDispatch_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, times: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requestcount: i32, startelement: i32, elements: i32, alternates: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, stream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resultblock: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuetypes: SpeechDiscardType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: SPXMLRESULTOPTIONS, presult: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, linenumber: *mut i32, scriptline: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, source: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, description: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, resultcode: *mut ::windows::core::HRESULT, iserror: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, feedback: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, wassuccessful: i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecoResultTimes(pub ::windows::core::IUnknown);
impl ISpeechRecoResultTimes {
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn StreamTime(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Length(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn TickCount(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn OffsetFromStart(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechRecoResultTimes {
type Vtable = ISpeechRecoResultTimes_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x62b3b8fb_f6e7_41be_bdcb_056b1c29efc0);
}
impl ::core::convert::From<ISpeechRecoResultTimes> for ::windows::core::IUnknown {
fn from(value: ISpeechRecoResultTimes) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecoResultTimes> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecoResultTimes) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecoResultTimes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecoResultTimes {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecoResultTimes> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecoResultTimes) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecoResultTimes> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecoResultTimes) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecoResultTimes {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecoResultTimes {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecoResultTimes_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, time: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, length: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, tickcount: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, offsetfromstart: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecognizer(pub ::windows::core::IUnknown);
impl ISpeechRecognizer {
pub unsafe fn putref_Recognizer<'a, Param0: ::windows::core::IntoParam<'a, ISpeechObjectToken>>(&self, recognizer: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), recognizer.into_param().abi()).ok()
}
pub unsafe fn Recognizer(&self) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
pub unsafe fn SetAllowAudioInputFormatChangesOnNextSet(&self, allow: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(allow)).ok()
}
pub unsafe fn AllowAudioInputFormatChangesOnNextSet(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn putref_AudioInput<'a, Param0: ::windows::core::IntoParam<'a, ISpeechObjectToken>>(&self, audioinput: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), audioinput.into_param().abi()).ok()
}
pub unsafe fn AudioInput(&self) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
pub unsafe fn putref_AudioInputStream<'a, Param0: ::windows::core::IntoParam<'a, ISpeechBaseStream>>(&self, audioinputstream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), audioinputstream.into_param().abi()).ok()
}
pub unsafe fn AudioInputStream(&self) -> ::windows::core::Result<ISpeechBaseStream> {
let mut result__: <ISpeechBaseStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechBaseStream>(result__)
}
pub unsafe fn IsShared(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetState(&self, state: SpeechRecognizerState) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(state)).ok()
}
pub unsafe fn State(&self) -> ::windows::core::Result<SpeechRecognizerState> {
let mut result__: <SpeechRecognizerState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRecognizerState>(result__)
}
pub unsafe fn Status(&self) -> ::windows::core::Result<ISpeechRecognizerStatus> {
let mut result__: <ISpeechRecognizerStatus as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecognizerStatus>(result__)
}
pub unsafe fn putref_Profile<'a, Param0: ::windows::core::IntoParam<'a, ISpeechObjectToken>>(&self, profile: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), profile.into_param().abi()).ok()
}
pub unsafe fn Profile(&self) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn EmulateRecognition<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, textelements: Param0, elementdisplayattributes: *const super::super::System::Com::VARIANT, languageid: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), textelements.into_param().abi(), ::core::mem::transmute(elementdisplayattributes), ::core::mem::transmute(languageid)).ok()
}
pub unsafe fn CreateRecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn GetFormat(&self, r#type: SpeechFormatType) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), ::core::mem::transmute(r#type), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyNumber<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, name: Param0, value: i32) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(value), &mut result__).from_abi::<i16>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyNumber<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, name: Param0, value: *mut i32, supported: *mut i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(value), ::core::mem::transmute(supported)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn SetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, name: Param0, value: Param1) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), name.into_param().abi(), value.into_param().abi(), &mut result__).from_abi::<i16>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetPropertyString<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, name: Param0, value: *mut super::super::Foundation::BSTR, supported: *mut i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), name.into_param().abi(), ::core::mem::transmute(value), ::core::mem::transmute(supported)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, typeofui: Param0, extradata: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), &mut result__).from_abi::<i16>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn DisplayUI<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, hwndparent: i32, title: Param1, typeofui: Param2, extradata: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), ::core::mem::transmute(hwndparent), title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetRecognizers<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAudioInputs<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetProfiles<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechRecognizer {
type Vtable = ISpeechRecognizer_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x2d5f1c0c_bd75_4b08_9478_3b11fea2586c);
}
impl ::core::convert::From<ISpeechRecognizer> for ::windows::core::IUnknown {
fn from(value: ISpeechRecognizer) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecognizer> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecognizer) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecognizer> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecognizer) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecognizer> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecognizer) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecognizer {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecognizer_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recognizer: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recognizer: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allow: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allow: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioinput: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioinput: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioinputstream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audioinputstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, shared: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: SpeechRecognizerState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut SpeechRecognizerState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, profile: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, profile: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, textelements: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, elementdisplayattributes: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, languageid: i32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, newcontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: SpeechFormatType, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: i32, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: *mut i32, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, name: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, value: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: i32, title: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, objecttokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, objecttokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, objecttokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechRecognizerStatus(pub ::windows::core::IUnknown);
impl ISpeechRecognizerStatus {
pub unsafe fn AudioStatus(&self) -> ::windows::core::Result<ISpeechAudioStatus> {
let mut result__: <ISpeechAudioStatus as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioStatus>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn CurrentStreamPosition(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn CurrentStreamNumber(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn NumberOfActiveRules(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ClsidEngine(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SupportedLanguages(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechRecognizerStatus {
type Vtable = ISpeechRecognizerStatus_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xbff9e781_53ec_484e_bb8a_0e1b5551e35c);
}
impl ::core::convert::From<ISpeechRecognizerStatus> for ::windows::core::IUnknown {
fn from(value: ISpeechRecognizerStatus) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechRecognizerStatus> for ::windows::core::IUnknown {
fn from(value: &ISpeechRecognizerStatus) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechRecognizerStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechRecognizerStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechRecognizerStatus> for super::super::System::Com::IDispatch {
fn from(value: ISpeechRecognizerStatus) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechRecognizerStatus> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechRecognizerStatus) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechRecognizerStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechRecognizerStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechRecognizerStatus_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiostatus: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pcurrentstreampos: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamnumber: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, numberofactiverules: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, clsidengine: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, supportedlanguages: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechResourceLoader(pub ::windows::core::IUnknown);
impl ISpeechResourceLoader {
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LoadResource<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrresourceuri: Param0, falwaysreload: i16, pstream: *mut ::core::option::Option<::windows::core::IUnknown>, pbstrmimetype: *mut super::super::Foundation::BSTR, pfmodified: *mut i16, pbstrredirecturl: *mut super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), bstrresourceuri.into_param().abi(), ::core::mem::transmute(falwaysreload), ::core::mem::transmute(pstream), ::core::mem::transmute(pbstrmimetype), ::core::mem::transmute(pfmodified), ::core::mem::transmute(pbstrredirecturl)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetLocalCopy<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, bstrresourceuri: Param0, pbstrlocalpath: *mut super::super::Foundation::BSTR, pbstrmimetype: *mut super::super::Foundation::BSTR, pbstrredirecturl: *mut super::super::Foundation::BSTR) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), bstrresourceuri.into_param().abi(), ::core::mem::transmute(pbstrlocalpath), ::core::mem::transmute(pbstrmimetype), ::core::mem::transmute(pbstrredirecturl)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn ReleaseLocalCopy<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, pbstrlocalpath: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), pbstrlocalpath.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechResourceLoader {
type Vtable = ISpeechResourceLoader_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xb9ac5783_fcd0_4b21_b119_b4f8da8fd2c3);
}
impl ::core::convert::From<ISpeechResourceLoader> for ::windows::core::IUnknown {
fn from(value: ISpeechResourceLoader) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechResourceLoader> for ::windows::core::IUnknown {
fn from(value: &ISpeechResourceLoader) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechResourceLoader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechResourceLoader {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechResourceLoader> for super::super::System::Com::IDispatch {
fn from(value: ISpeechResourceLoader) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechResourceLoader> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechResourceLoader) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechResourceLoader {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechResourceLoader {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechResourceLoader_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrresourceuri: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, falwaysreload: i16, pstream: *mut ::windows::core::RawPtr, pbstrmimetype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pfmodified: *mut i16, pbstrredirecturl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bstrresourceuri: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbstrlocalpath: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbstrmimetype: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, pbstrredirecturl: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pbstrlocalpath: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechTextSelectionInformation(pub ::windows::core::IUnknown);
impl ISpeechTextSelectionInformation {
pub unsafe fn SetActiveOffset(&self, activeoffset: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), ::core::mem::transmute(activeoffset)).ok()
}
pub unsafe fn ActiveOffset(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetActiveLength(&self, activelength: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), ::core::mem::transmute(activelength)).ok()
}
pub unsafe fn ActiveLength(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetSelectionOffset(&self, selectionoffset: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), ::core::mem::transmute(selectionoffset)).ok()
}
pub unsafe fn SelectionOffset(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetSelectionLength(&self, selectionlength: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(selectionlength)).ok()
}
pub unsafe fn SelectionLength(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechTextSelectionInformation {
type Vtable = ISpeechTextSelectionInformation_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3b9c7e7a_6eee_4ded_9092_11657279adbe);
}
impl ::core::convert::From<ISpeechTextSelectionInformation> for ::windows::core::IUnknown {
fn from(value: ISpeechTextSelectionInformation) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechTextSelectionInformation> for ::windows::core::IUnknown {
fn from(value: &ISpeechTextSelectionInformation) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechTextSelectionInformation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechTextSelectionInformation {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechTextSelectionInformation> for super::super::System::Com::IDispatch {
fn from(value: ISpeechTextSelectionInformation) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechTextSelectionInformation> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechTextSelectionInformation) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechTextSelectionInformation {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechTextSelectionInformation {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechTextSelectionInformation_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, activeoffset: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, activeoffset: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, activelength: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, activelength: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, selectionoffset: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, selectionoffset: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, selectionlength: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, selectionlength: *mut i32) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechVoice(pub ::windows::core::IUnknown);
impl ISpeechVoice {
pub unsafe fn Status(&self) -> ::windows::core::Result<ISpeechVoiceStatus> {
let mut result__: <ISpeechVoiceStatus as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechVoiceStatus>(result__)
}
pub unsafe fn Voice(&self) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
pub unsafe fn putref_Voice<'a, Param0: ::windows::core::IntoParam<'a, ISpeechObjectToken>>(&self, voice: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), voice.into_param().abi()).ok()
}
pub unsafe fn AudioOutput(&self) -> ::windows::core::Result<ISpeechObjectToken> {
let mut result__: <ISpeechObjectToken as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechObjectToken>(result__)
}
pub unsafe fn putref_AudioOutput<'a, Param0: ::windows::core::IntoParam<'a, ISpeechObjectToken>>(&self, audiooutput: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), audiooutput.into_param().abi()).ok()
}
pub unsafe fn AudioOutputStream(&self) -> ::windows::core::Result<ISpeechBaseStream> {
let mut result__: <ISpeechBaseStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechBaseStream>(result__)
}
pub unsafe fn putref_AudioOutputStream<'a, Param0: ::windows::core::IntoParam<'a, ISpeechBaseStream>>(&self, audiooutputstream: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), audiooutputstream.into_param().abi()).ok()
}
pub unsafe fn Rate(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetRate(&self, rate: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), ::core::mem::transmute(rate)).ok()
}
pub unsafe fn Volume(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetVolume(&self, volume: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(volume)).ok()
}
pub unsafe fn SetAllowAudioOutputFormatChangesOnNextSet(&self, allow: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(allow)).ok()
}
pub unsafe fn AllowAudioOutputFormatChangesOnNextSet(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn EventInterests(&self) -> ::windows::core::Result<SpeechVoiceEvents> {
let mut result__: <SpeechVoiceEvents as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechVoiceEvents>(result__)
}
pub unsafe fn SetEventInterests(&self, eventinterestflags: SpeechVoiceEvents) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).21)(::core::mem::transmute_copy(self), ::core::mem::transmute(eventinterestflags)).ok()
}
pub unsafe fn SetPriority(&self, priority: SpeechVoicePriority) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).22)(::core::mem::transmute_copy(self), ::core::mem::transmute(priority)).ok()
}
pub unsafe fn Priority(&self) -> ::windows::core::Result<SpeechVoicePriority> {
let mut result__: <SpeechVoicePriority as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).23)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechVoicePriority>(result__)
}
pub unsafe fn SetAlertBoundary(&self, boundary: SpeechVoiceEvents) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).24)(::core::mem::transmute_copy(self), ::core::mem::transmute(boundary)).ok()
}
pub unsafe fn AlertBoundary(&self) -> ::windows::core::Result<SpeechVoiceEvents> {
let mut result__: <SpeechVoiceEvents as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).25)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechVoiceEvents>(result__)
}
pub unsafe fn SetSynchronousSpeakTimeout(&self, mstimeout: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).26)(::core::mem::transmute_copy(self), ::core::mem::transmute(mstimeout)).ok()
}
pub unsafe fn SynchronousSpeakTimeout(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).27)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Speak<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, text: Param0, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).28)(::core::mem::transmute_copy(self), text.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SpeakStream<'a, Param0: ::windows::core::IntoParam<'a, ISpeechBaseStream>>(&self, stream: Param0, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).29)(::core::mem::transmute_copy(self), stream.into_param().abi(), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn Pause(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).30)(::core::mem::transmute_copy(self)).ok()
}
pub unsafe fn Resume(&self) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).31)(::core::mem::transmute_copy(self)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn Skip<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, r#type: Param0, numitems: i32) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).32)(::core::mem::transmute_copy(self), r#type.into_param().abi(), ::core::mem::transmute(numitems), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetVoices<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).33)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetAudioOutputs<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, requiredattributes: Param0, optionalattributes: Param1) -> ::windows::core::Result<ISpeechObjectTokens> {
let mut result__: <ISpeechObjectTokens as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).34)(::core::mem::transmute_copy(self), requiredattributes.into_param().abi(), optionalattributes.into_param().abi(), &mut result__).from_abi::<ISpeechObjectTokens>(result__)
}
pub unsafe fn WaitUntilDone(&self, mstimeout: i32) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).35)(::core::mem::transmute_copy(self), ::core::mem::transmute(mstimeout), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SpeakCompleteEvent(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).36)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn IsUISupported<'a, Param0: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, typeofui: Param0, extradata: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).37)(::core::mem::transmute_copy(self), typeofui.into_param().abi(), ::core::mem::transmute(extradata), &mut result__).from_abi::<i16>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn DisplayUI<'a, Param1: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>, Param2: ::windows::core::IntoParam<'a, super::super::Foundation::BSTR>>(&self, hwndparent: i32, title: Param1, typeofui: Param2, extradata: *const super::super::System::Com::VARIANT) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).38)(::core::mem::transmute_copy(self), ::core::mem::transmute(hwndparent), title.into_param().abi(), typeofui.into_param().abi(), ::core::mem::transmute(extradata)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechVoice {
type Vtable = ISpeechVoice_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x269316d8_57bd_11d2_9eee_00c04f797396);
}
impl ::core::convert::From<ISpeechVoice> for ::windows::core::IUnknown {
fn from(value: ISpeechVoice) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechVoice> for ::windows::core::IUnknown {
fn from(value: &ISpeechVoice) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechVoice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechVoice {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechVoice> for super::super::System::Com::IDispatch {
fn from(value: ISpeechVoice) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechVoice> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechVoice) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechVoice {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechVoice {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechVoice_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, status: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, voice: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, voice: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiooutput: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiooutput: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiooutputstream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, audiooutputstream: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, rate: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, volume: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allow: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, allow: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterestflags: *mut SpeechVoiceEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, eventinterestflags: SpeechVoiceEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, priority: SpeechVoicePriority) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, priority: *mut SpeechVoicePriority) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, boundary: SpeechVoiceEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, boundary: *mut SpeechVoiceEvents) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mstimeout: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mstimeout: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, text: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, stream: ::windows::core::RawPtr, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, r#type: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, numitems: i32, numskipped: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, objecttokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requiredattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, optionalattributes: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, objecttokens: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, mstimeout: i32, done: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, handle: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, supported: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hwndparent: i32, title: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, typeofui: ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, extradata: *const ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechVoiceStatus(pub ::windows::core::IUnknown);
impl ISpeechVoiceStatus {
pub unsafe fn CurrentStreamNumber(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn LastStreamNumberQueued(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn LastHResult(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn RunningState(&self) -> ::windows::core::Result<SpeechRunState> {
let mut result__: <SpeechRunState as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<SpeechRunState>(result__)
}
pub unsafe fn InputWordPosition(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn InputWordLength(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn InputSentencePosition(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn InputSentenceLength(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn LastBookmark(&self) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
pub unsafe fn LastBookmarkId(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn PhonemeId(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn VisemeId(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
}
unsafe impl ::windows::core::Interface for ISpeechVoiceStatus {
type Vtable = ISpeechVoiceStatus_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8be47b07_57f6_11d2_9eee_00c04f797396);
}
impl ::core::convert::From<ISpeechVoiceStatus> for ::windows::core::IUnknown {
fn from(value: ISpeechVoiceStatus) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechVoiceStatus> for ::windows::core::IUnknown {
fn from(value: &ISpeechVoiceStatus) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechVoiceStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechVoiceStatus {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechVoiceStatus> for super::super::System::Com::IDispatch {
fn from(value: ISpeechVoiceStatus) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechVoiceStatus> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechVoiceStatus) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechVoiceStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechVoiceStatus {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechVoiceStatus_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamnumber: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, streamnumber: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, hresult: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, state: *mut SpeechRunState) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, length: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, position: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, length: *mut i32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bookmark: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bookmarkid: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phoneid: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, visemeid: *mut i16) -> ::windows::core::HRESULT,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechWaveFormatEx(pub ::windows::core::IUnknown);
impl ISpeechWaveFormatEx {
pub unsafe fn FormatTag(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetFormatTag(&self, formattag: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), ::core::mem::transmute(formattag)).ok()
}
pub unsafe fn Channels(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetChannels(&self, channels: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), ::core::mem::transmute(channels)).ok()
}
pub unsafe fn SamplesPerSec(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetSamplesPerSec(&self, samplespersec: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(samplespersec)).ok()
}
pub unsafe fn AvgBytesPerSec(&self) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i32>(result__)
}
pub unsafe fn SetAvgBytesPerSec(&self, avgbytespersec: i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(avgbytespersec)).ok()
}
pub unsafe fn BlockAlign(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetBlockAlign(&self, blockalign: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(blockalign)).ok()
}
pub unsafe fn BitsPerSample(&self) -> ::windows::core::Result<i16> {
let mut result__: <i16 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), &mut result__).from_abi::<i16>(result__)
}
pub unsafe fn SetBitsPerSample(&self, bitspersample: i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(bitspersample)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn ExtraData(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).19)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SetExtraData<'a, Param0: ::windows::core::IntoParam<'a, super::super::System::Com::VARIANT>>(&self, extradata: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).20)(::core::mem::transmute_copy(self), extradata.into_param().abi()).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechWaveFormatEx {
type Vtable = ISpeechWaveFormatEx_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7a1ef0d5_1581_4741_88e4_209a49f11a10);
}
impl ::core::convert::From<ISpeechWaveFormatEx> for ::windows::core::IUnknown {
fn from(value: ISpeechWaveFormatEx) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechWaveFormatEx> for ::windows::core::IUnknown {
fn from(value: &ISpeechWaveFormatEx) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechWaveFormatEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechWaveFormatEx {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechWaveFormatEx> for super::super::System::Com::IDispatch {
fn from(value: ISpeechWaveFormatEx) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechWaveFormatEx> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechWaveFormatEx) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechWaveFormatEx {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechWaveFormatEx {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechWaveFormatEx_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formattag: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, formattag: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, channels: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, channels: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, samplespersec: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, samplespersec: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, avgbytespersec: *mut i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, avgbytespersec: i32) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, blockalign: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, blockalign: i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bitspersample: *mut i16) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, bitspersample: i16) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, extradata: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, extradata: ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct ISpeechXMLRecoResult(pub ::windows::core::IUnknown);
impl ISpeechXMLRecoResult {
pub unsafe fn GetTypeInfoCount(&self) -> ::windows::core::Result<u32> {
let mut result__: <u32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).3)(::core::mem::transmute_copy(self), &mut result__).from_abi::<u32>(result__)
}
#[cfg(feature = "Win32_System_Com")]
pub unsafe fn GetTypeInfo(&self, itinfo: u32, lcid: u32) -> ::windows::core::Result<super::super::System::Com::ITypeInfo> {
let mut result__: <super::super::System::Com::ITypeInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).4)(::core::mem::transmute_copy(self), ::core::mem::transmute(itinfo), ::core::mem::transmute(lcid), &mut result__).from_abi::<super::super::System::Com::ITypeInfo>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetIDsOfNames(&self, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).5)(::core::mem::transmute_copy(self), ::core::mem::transmute(riid), ::core::mem::transmute(rgsznames), ::core::mem::transmute(cnames), ::core::mem::transmute(lcid), ::core::mem::transmute(rgdispid)).ok()
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn Invoke(&self, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut super::super::System::Com::VARIANT, pexcepinfo: *mut super::super::System::Com::EXCEPINFO, puargerr: *mut u32) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).6)(
::core::mem::transmute_copy(self),
::core::mem::transmute(dispidmember),
::core::mem::transmute(riid),
::core::mem::transmute(lcid),
::core::mem::transmute(wflags),
::core::mem::transmute(pdispparams),
::core::mem::transmute(pvarresult),
::core::mem::transmute(pexcepinfo),
::core::mem::transmute(puargerr),
)
.ok()
}
pub unsafe fn RecoContext(&self) -> ::windows::core::Result<ISpeechRecoContext> {
let mut result__: <ISpeechRecoContext as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).7)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoContext>(result__)
}
pub unsafe fn Times(&self) -> ::windows::core::Result<ISpeechRecoResultTimes> {
let mut result__: <ISpeechRecoResultTimes as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).8)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechRecoResultTimes>(result__)
}
pub unsafe fn putref_AudioFormat<'a, Param0: ::windows::core::IntoParam<'a, ISpeechAudioFormat>>(&self, format: Param0) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).9)(::core::mem::transmute_copy(self), format.into_param().abi()).ok()
}
pub unsafe fn AudioFormat(&self) -> ::windows::core::Result<ISpeechAudioFormat> {
let mut result__: <ISpeechAudioFormat as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).10)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechAudioFormat>(result__)
}
pub unsafe fn PhraseInfo(&self) -> ::windows::core::Result<ISpeechPhraseInfo> {
let mut result__: <ISpeechPhraseInfo as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).11)(::core::mem::transmute_copy(self), &mut result__).from_abi::<ISpeechPhraseInfo>(result__)
}
pub unsafe fn Alternates(&self, requestcount: i32, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechPhraseAlternates> {
let mut result__: <ISpeechPhraseAlternates as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).12)(::core::mem::transmute_copy(self), ::core::mem::transmute(requestcount), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechPhraseAlternates>(result__)
}
pub unsafe fn Audio(&self, startelement: i32, elements: i32) -> ::windows::core::Result<ISpeechMemoryStream> {
let mut result__: <ISpeechMemoryStream as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).13)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), &mut result__).from_abi::<ISpeechMemoryStream>(result__)
}
pub unsafe fn SpeakAudio(&self, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags) -> ::windows::core::Result<i32> {
let mut result__: <i32 as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).14)(::core::mem::transmute_copy(self), ::core::mem::transmute(startelement), ::core::mem::transmute(elements), ::core::mem::transmute(flags), &mut result__).from_abi::<i32>(result__)
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe fn SaveToMemory(&self) -> ::windows::core::Result<super::super::System::Com::VARIANT> {
let mut result__: <super::super::System::Com::VARIANT as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).15)(::core::mem::transmute_copy(self), &mut result__).from_abi::<super::super::System::Com::VARIANT>(result__)
}
pub unsafe fn DiscardResultInfo(&self, valuetypes: SpeechDiscardType) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).16)(::core::mem::transmute_copy(self), ::core::mem::transmute(valuetypes)).ok()
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLResult(&self, options: SPXMLRESULTOPTIONS) -> ::windows::core::Result<super::super::Foundation::BSTR> {
let mut result__: <super::super::Foundation::BSTR as ::windows::core::Abi>::Abi = ::core::mem::zeroed();
(::windows::core::Interface::vtable(self).17)(::core::mem::transmute_copy(self), ::core::mem::transmute(options), &mut result__).from_abi::<super::super::Foundation::BSTR>(result__)
}
#[cfg(feature = "Win32_Foundation")]
pub unsafe fn GetXMLErrorInfo(&self, linenumber: *mut i32, scriptline: *mut super::super::Foundation::BSTR, source: *mut super::super::Foundation::BSTR, description: *mut super::super::Foundation::BSTR, resultcode: *mut i32, iserror: *mut i16) -> ::windows::core::Result<()> {
(::windows::core::Interface::vtable(self).18)(::core::mem::transmute_copy(self), ::core::mem::transmute(linenumber), ::core::mem::transmute(scriptline), ::core::mem::transmute(source), ::core::mem::transmute(description), ::core::mem::transmute(resultcode), ::core::mem::transmute(iserror)).ok()
}
}
unsafe impl ::windows::core::Interface for ISpeechXMLRecoResult {
type Vtable = ISpeechXMLRecoResult_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xaaec54af_8f85_4924_944d_b79d39d72e19);
}
impl ::core::convert::From<ISpeechXMLRecoResult> for ::windows::core::IUnknown {
fn from(value: ISpeechXMLRecoResult) -> Self {
value.0
}
}
impl ::core::convert::From<&ISpeechXMLRecoResult> for ::windows::core::IUnknown {
fn from(value: &ISpeechXMLRecoResult) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
impl ::core::convert::From<ISpeechXMLRecoResult> for ISpeechRecoResult {
fn from(value: ISpeechXMLRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
impl ::core::convert::From<&ISpeechXMLRecoResult> for ISpeechRecoResult {
fn from(value: &ISpeechXMLRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechRecoResult> for ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechRecoResult> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
impl<'a> ::windows::core::IntoParam<'a, ISpeechRecoResult> for &ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, ISpeechRecoResult> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<ISpeechXMLRecoResult> for super::super::System::Com::IDispatch {
fn from(value: ISpeechXMLRecoResult) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&ISpeechXMLRecoResult> for super::super::System::Com::IDispatch {
fn from(value: &ISpeechXMLRecoResult) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &ISpeechXMLRecoResult {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct ISpeechXMLRecoResult_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, recocontext: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, times: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, format: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, phraseinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, requestcount: i32, startelement: i32, elements: i32, alternates: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, stream: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, startelement: i32, elements: i32, flags: SpeechVoiceSpeakFlags, streamnumber: *mut i32) -> ::windows::core::HRESULT,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, resultblock: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, valuetypes: SpeechDiscardType) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, options: SPXMLRESULTOPTIONS, presult: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, linenumber: *mut i32, scriptline: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, source: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, description: *mut ::core::mem::ManuallyDrop<super::super::Foundation::BSTR>, resultcode: *mut i32, iserror: *mut i16) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct PHONETICALPHABET(pub i32);
pub const PA_Ipa: PHONETICALPHABET = PHONETICALPHABET(0i32);
pub const PA_Ups: PHONETICALPHABET = PHONETICALPHABET(1i32);
pub const PA_Sapi: PHONETICALPHABET = PHONETICALPHABET(2i32);
impl ::core::convert::From<i32> for PHONETICALPHABET {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for PHONETICALPHABET {
type Abi = Self;
}
pub const SAPI_ERROR_BASE: u32 = 20480u32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPADAPTATIONRELEVANCE(pub i32);
pub const SPAR_Unknown: SPADAPTATIONRELEVANCE = SPADAPTATIONRELEVANCE(0i32);
pub const SPAR_Low: SPADAPTATIONRELEVANCE = SPADAPTATIONRELEVANCE(1i32);
pub const SPAR_Medium: SPADAPTATIONRELEVANCE = SPADAPTATIONRELEVANCE(2i32);
pub const SPAR_High: SPADAPTATIONRELEVANCE = SPADAPTATIONRELEVANCE(3i32);
impl ::core::convert::From<i32> for SPADAPTATIONRELEVANCE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPADAPTATIONRELEVANCE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPADAPTATIONSETTINGS(pub i32);
pub const SPADS_Default: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(0i32);
pub const SPADS_CurrentRecognizer: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(1i32);
pub const SPADS_RecoProfile: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(2i32);
pub const SPADS_Immediate: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(4i32);
pub const SPADS_Reset: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(8i32);
pub const SPADS_HighVolumeDataSource: SPADAPTATIONSETTINGS = SPADAPTATIONSETTINGS(16i32);
impl ::core::convert::From<i32> for SPADAPTATIONSETTINGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPADAPTATIONSETTINGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPAUDIOBUFFERINFO {
pub ulMsMinNotification: u32,
pub ulMsBufferSize: u32,
pub ulMsEventBias: u32,
}
impl SPAUDIOBUFFERINFO {}
impl ::core::default::Default for SPAUDIOBUFFERINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPAUDIOBUFFERINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPAUDIOBUFFERINFO").field("ulMsMinNotification", &self.ulMsMinNotification).field("ulMsBufferSize", &self.ulMsBufferSize).field("ulMsEventBias", &self.ulMsEventBias).finish()
}
}
impl ::core::cmp::PartialEq for SPAUDIOBUFFERINFO {
fn eq(&self, other: &Self) -> bool {
self.ulMsMinNotification == other.ulMsMinNotification && self.ulMsBufferSize == other.ulMsBufferSize && self.ulMsEventBias == other.ulMsEventBias
}
}
impl ::core::cmp::Eq for SPAUDIOBUFFERINFO {}
unsafe impl ::windows::core::Abi for SPAUDIOBUFFERINFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPAUDIOOPTIONS(pub i32);
pub const SPAO_NONE: SPAUDIOOPTIONS = SPAUDIOOPTIONS(0i32);
pub const SPAO_RETAIN_AUDIO: SPAUDIOOPTIONS = SPAUDIOOPTIONS(1i32);
impl ::core::convert::From<i32> for SPAUDIOOPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPAUDIOOPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPAUDIOSTATE(pub i32);
pub const SPAS_CLOSED: SPAUDIOSTATE = SPAUDIOSTATE(0i32);
pub const SPAS_STOP: SPAUDIOSTATE = SPAUDIOSTATE(1i32);
pub const SPAS_PAUSE: SPAUDIOSTATE = SPAUDIOSTATE(2i32);
pub const SPAS_RUN: SPAUDIOSTATE = SPAUDIOSTATE(3i32);
impl ::core::convert::From<i32> for SPAUDIOSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPAUDIOSTATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPAUDIOSTATUS {
pub cbFreeBuffSpace: i32,
pub cbNonBlockingIO: u32,
pub State: SPAUDIOSTATE,
pub CurSeekPos: u64,
pub CurDevicePos: u64,
pub dwAudioLevel: u32,
pub dwReserved2: u32,
}
impl SPAUDIOSTATUS {}
impl ::core::default::Default for SPAUDIOSTATUS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPAUDIOSTATUS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPAUDIOSTATUS")
.field("cbFreeBuffSpace", &self.cbFreeBuffSpace)
.field("cbNonBlockingIO", &self.cbNonBlockingIO)
.field("State", &self.State)
.field("CurSeekPos", &self.CurSeekPos)
.field("CurDevicePos", &self.CurDevicePos)
.field("dwAudioLevel", &self.dwAudioLevel)
.field("dwReserved2", &self.dwReserved2)
.finish()
}
}
impl ::core::cmp::PartialEq for SPAUDIOSTATUS {
fn eq(&self, other: &Self) -> bool {
self.cbFreeBuffSpace == other.cbFreeBuffSpace && self.cbNonBlockingIO == other.cbNonBlockingIO && self.State == other.State && self.CurSeekPos == other.CurSeekPos && self.CurDevicePos == other.CurDevicePos && self.dwAudioLevel == other.dwAudioLevel && self.dwReserved2 == other.dwReserved2
}
}
impl ::core::cmp::Eq for SPAUDIOSTATUS {}
unsafe impl ::windows::core::Abi for SPAUDIOSTATUS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPBINARYGRAMMAR {
pub ulTotalSerializedSize: u32,
}
impl SPBINARYGRAMMAR {}
impl ::core::default::Default for SPBINARYGRAMMAR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPBINARYGRAMMAR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPBINARYGRAMMAR").field("ulTotalSerializedSize", &self.ulTotalSerializedSize).finish()
}
}
impl ::core::cmp::PartialEq for SPBINARYGRAMMAR {
fn eq(&self, other: &Self) -> bool {
self.ulTotalSerializedSize == other.ulTotalSerializedSize
}
}
impl ::core::cmp::Eq for SPBINARYGRAMMAR {}
unsafe impl ::windows::core::Abi for SPBINARYGRAMMAR {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPBOOKMARKOPTIONS(pub i32);
pub const SPBO_NONE: SPBOOKMARKOPTIONS = SPBOOKMARKOPTIONS(0i32);
pub const SPBO_PAUSE: SPBOOKMARKOPTIONS = SPBOOKMARKOPTIONS(1i32);
pub const SPBO_AHEAD: SPBOOKMARKOPTIONS = SPBOOKMARKOPTIONS(2i32);
pub const SPBO_TIME_UNITS: SPBOOKMARKOPTIONS = SPBOOKMARKOPTIONS(4i32);
impl ::core::convert::From<i32> for SPBOOKMARKOPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPBOOKMARKOPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPCFGRULEATTRIBUTES(pub i32);
pub const SPRAF_TopLevel: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(1i32);
pub const SPRAF_Active: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(2i32);
pub const SPRAF_Export: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(4i32);
pub const SPRAF_Import: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(8i32);
pub const SPRAF_Interpreter: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(16i32);
pub const SPRAF_Dynamic: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(32i32);
pub const SPRAF_Root: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(64i32);
pub const SPRAF_AutoPause: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(65536i32);
pub const SPRAF_UserDelimited: SPCFGRULEATTRIBUTES = SPCFGRULEATTRIBUTES(131072i32);
impl ::core::convert::From<i32> for SPCFGRULEATTRIBUTES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPCFGRULEATTRIBUTES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPCOMMITFLAGS(pub i32);
pub const SPCF_NONE: SPCOMMITFLAGS = SPCOMMITFLAGS(0i32);
pub const SPCF_ADD_TO_USER_LEXICON: SPCOMMITFLAGS = SPCOMMITFLAGS(1i32);
pub const SPCF_DEFINITE_CORRECTION: SPCOMMITFLAGS = SPCOMMITFLAGS(2i32);
impl ::core::convert::From<i32> for SPCOMMITFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPCOMMITFLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPCONTEXTSTATE(pub i32);
pub const SPCS_DISABLED: SPCONTEXTSTATE = SPCONTEXTSTATE(0i32);
pub const SPCS_ENABLED: SPCONTEXTSTATE = SPCONTEXTSTATE(1i32);
impl ::core::convert::From<i32> for SPCONTEXTSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPCONTEXTSTATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPDATAKEYLOCATION(pub i32);
pub const SPDKL_DefaultLocation: SPDATAKEYLOCATION = SPDATAKEYLOCATION(0i32);
pub const SPDKL_CurrentUser: SPDATAKEYLOCATION = SPDATAKEYLOCATION(1i32);
pub const SPDKL_LocalMachine: SPDATAKEYLOCATION = SPDATAKEYLOCATION(2i32);
pub const SPDKL_CurrentConfig: SPDATAKEYLOCATION = SPDATAKEYLOCATION(5i32);
impl ::core::convert::From<i32> for SPDATAKEYLOCATION {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPDATAKEYLOCATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPDISPLAYPHRASE {
pub ulNumTokens: u32,
pub pTokens: *mut SPDISPLAYTOKEN,
}
#[cfg(feature = "Win32_Foundation")]
impl SPDISPLAYPHRASE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPDISPLAYPHRASE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPDISPLAYPHRASE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPDISPLAYPHRASE").field("ulNumTokens", &self.ulNumTokens).field("pTokens", &self.pTokens).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPDISPLAYPHRASE {
fn eq(&self, other: &Self) -> bool {
self.ulNumTokens == other.ulNumTokens && self.pTokens == other.pTokens
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPDISPLAYPHRASE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPDISPLAYPHRASE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPDISPLAYTOKEN {
pub pszLexical: super::super::Foundation::PWSTR,
pub pszDisplay: super::super::Foundation::PWSTR,
pub bDisplayAttributes: u8,
}
#[cfg(feature = "Win32_Foundation")]
impl SPDISPLAYTOKEN {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPDISPLAYTOKEN {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPDISPLAYTOKEN {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPDISPLAYTOKEN").field("pszLexical", &self.pszLexical).field("pszDisplay", &self.pszDisplay).field("bDisplayAttributes", &self.bDisplayAttributes).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPDISPLAYTOKEN {
fn eq(&self, other: &Self) -> bool {
self.pszLexical == other.pszLexical && self.pszDisplay == other.pszDisplay && self.bDisplayAttributes == other.bDisplayAttributes
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPDISPLAYTOKEN {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPDISPLAYTOKEN {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPDISPLYATTRIBUTES(pub i32);
pub const SPAF_ONE_TRAILING_SPACE: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(2i32);
pub const SPAF_TWO_TRAILING_SPACES: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(4i32);
pub const SPAF_CONSUME_LEADING_SPACES: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(8i32);
pub const SPAF_BUFFER_POSITION: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(16i32);
pub const SPAF_ALL: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(31i32);
pub const SPAF_USER_SPECIFIED: SPDISPLYATTRIBUTES = SPDISPLYATTRIBUTES(128i32);
impl ::core::convert::From<i32> for SPDISPLYATTRIBUTES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPDISPLYATTRIBUTES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPEAKFLAGS(pub i32);
pub const SPF_DEFAULT: SPEAKFLAGS = SPEAKFLAGS(0i32);
pub const SPF_ASYNC: SPEAKFLAGS = SPEAKFLAGS(1i32);
pub const SPF_PURGEBEFORESPEAK: SPEAKFLAGS = SPEAKFLAGS(2i32);
pub const SPF_IS_FILENAME: SPEAKFLAGS = SPEAKFLAGS(4i32);
pub const SPF_IS_XML: SPEAKFLAGS = SPEAKFLAGS(8i32);
pub const SPF_IS_NOT_XML: SPEAKFLAGS = SPEAKFLAGS(16i32);
pub const SPF_PERSIST_XML: SPEAKFLAGS = SPEAKFLAGS(32i32);
pub const SPF_NLP_SPEAK_PUNC: SPEAKFLAGS = SPEAKFLAGS(64i32);
pub const SPF_PARSE_SAPI: SPEAKFLAGS = SPEAKFLAGS(128i32);
pub const SPF_PARSE_SSML: SPEAKFLAGS = SPEAKFLAGS(256i32);
pub const SPF_PARSE_AUTODETECT: SPEAKFLAGS = SPEAKFLAGS(0i32);
pub const SPF_NLP_MASK: SPEAKFLAGS = SPEAKFLAGS(64i32);
pub const SPF_PARSE_MASK: SPEAKFLAGS = SPEAKFLAGS(384i32);
pub const SPF_VOICE_MASK: SPEAKFLAGS = SPEAKFLAGS(511i32);
pub const SPF_UNUSED_FLAGS: SPEAKFLAGS = SPEAKFLAGS(-512i32);
impl ::core::convert::From<i32> for SPEAKFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPEAKFLAGS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPENDSRSTREAMFLAGS(pub i32);
pub const SPESF_NONE: SPENDSRSTREAMFLAGS = SPENDSRSTREAMFLAGS(0i32);
pub const SPESF_STREAM_RELEASED: SPENDSRSTREAMFLAGS = SPENDSRSTREAMFLAGS(1i32);
pub const SPESF_EMULATED: SPENDSRSTREAMFLAGS = SPENDSRSTREAMFLAGS(2i32);
impl ::core::convert::From<i32> for SPENDSRSTREAMFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPENDSRSTREAMFLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPEVENT {
pub _bitfield: i32,
pub ulStreamNum: u32,
pub ullAudioStreamOffset: u64,
pub wParam: super::super::Foundation::WPARAM,
pub lParam: super::super::Foundation::LPARAM,
}
#[cfg(feature = "Win32_Foundation")]
impl SPEVENT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPEVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPEVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPEVENT").field("_bitfield", &self._bitfield).field("ulStreamNum", &self.ulStreamNum).field("ullAudioStreamOffset", &self.ullAudioStreamOffset).field("wParam", &self.wParam).field("lParam", &self.lParam).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPEVENT {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield && self.ulStreamNum == other.ulStreamNum && self.ullAudioStreamOffset == other.ullAudioStreamOffset && self.wParam == other.wParam && self.lParam == other.lParam
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPEVENT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPEVENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPEVENTENUM(pub i32);
pub const SPEI_UNDEFINED: SPEVENTENUM = SPEVENTENUM(0i32);
pub const SPEI_START_INPUT_STREAM: SPEVENTENUM = SPEVENTENUM(1i32);
pub const SPEI_END_INPUT_STREAM: SPEVENTENUM = SPEVENTENUM(2i32);
pub const SPEI_VOICE_CHANGE: SPEVENTENUM = SPEVENTENUM(3i32);
pub const SPEI_TTS_BOOKMARK: SPEVENTENUM = SPEVENTENUM(4i32);
pub const SPEI_WORD_BOUNDARY: SPEVENTENUM = SPEVENTENUM(5i32);
pub const SPEI_PHONEME: SPEVENTENUM = SPEVENTENUM(6i32);
pub const SPEI_SENTENCE_BOUNDARY: SPEVENTENUM = SPEVENTENUM(7i32);
pub const SPEI_VISEME: SPEVENTENUM = SPEVENTENUM(8i32);
pub const SPEI_TTS_AUDIO_LEVEL: SPEVENTENUM = SPEVENTENUM(9i32);
pub const SPEI_TTS_PRIVATE: SPEVENTENUM = SPEVENTENUM(15i32);
pub const SPEI_MIN_TTS: SPEVENTENUM = SPEVENTENUM(1i32);
pub const SPEI_MAX_TTS: SPEVENTENUM = SPEVENTENUM(15i32);
pub const SPEI_END_SR_STREAM: SPEVENTENUM = SPEVENTENUM(34i32);
pub const SPEI_SOUND_START: SPEVENTENUM = SPEVENTENUM(35i32);
pub const SPEI_SOUND_END: SPEVENTENUM = SPEVENTENUM(36i32);
pub const SPEI_PHRASE_START: SPEVENTENUM = SPEVENTENUM(37i32);
pub const SPEI_RECOGNITION: SPEVENTENUM = SPEVENTENUM(38i32);
pub const SPEI_HYPOTHESIS: SPEVENTENUM = SPEVENTENUM(39i32);
pub const SPEI_SR_BOOKMARK: SPEVENTENUM = SPEVENTENUM(40i32);
pub const SPEI_PROPERTY_NUM_CHANGE: SPEVENTENUM = SPEVENTENUM(41i32);
pub const SPEI_PROPERTY_STRING_CHANGE: SPEVENTENUM = SPEVENTENUM(42i32);
pub const SPEI_FALSE_RECOGNITION: SPEVENTENUM = SPEVENTENUM(43i32);
pub const SPEI_INTERFERENCE: SPEVENTENUM = SPEVENTENUM(44i32);
pub const SPEI_REQUEST_UI: SPEVENTENUM = SPEVENTENUM(45i32);
pub const SPEI_RECO_STATE_CHANGE: SPEVENTENUM = SPEVENTENUM(46i32);
pub const SPEI_ADAPTATION: SPEVENTENUM = SPEVENTENUM(47i32);
pub const SPEI_START_SR_STREAM: SPEVENTENUM = SPEVENTENUM(48i32);
pub const SPEI_RECO_OTHER_CONTEXT: SPEVENTENUM = SPEVENTENUM(49i32);
pub const SPEI_SR_AUDIO_LEVEL: SPEVENTENUM = SPEVENTENUM(50i32);
pub const SPEI_SR_RETAINEDAUDIO: SPEVENTENUM = SPEVENTENUM(51i32);
pub const SPEI_SR_PRIVATE: SPEVENTENUM = SPEVENTENUM(52i32);
pub const SPEI_RESERVED4: SPEVENTENUM = SPEVENTENUM(53i32);
pub const SPEI_RESERVED5: SPEVENTENUM = SPEVENTENUM(54i32);
pub const SPEI_RESERVED6: SPEVENTENUM = SPEVENTENUM(55i32);
pub const SPEI_MIN_SR: SPEVENTENUM = SPEVENTENUM(34i32);
pub const SPEI_MAX_SR: SPEVENTENUM = SPEVENTENUM(55i32);
pub const SPEI_RESERVED1: SPEVENTENUM = SPEVENTENUM(30i32);
pub const SPEI_RESERVED2: SPEVENTENUM = SPEVENTENUM(33i32);
pub const SPEI_RESERVED3: SPEVENTENUM = SPEVENTENUM(63i32);
impl ::core::convert::From<i32> for SPEVENTENUM {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPEVENTENUM {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPEVENTEX {
pub _bitfield: i32,
pub ulStreamNum: u32,
pub ullAudioStreamOffset: u64,
pub wParam: super::super::Foundation::WPARAM,
pub lParam: super::super::Foundation::LPARAM,
pub ullAudioTimeOffset: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl SPEVENTEX {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPEVENTEX {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPEVENTEX {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPEVENTEX").field("_bitfield", &self._bitfield).field("ulStreamNum", &self.ulStreamNum).field("ullAudioStreamOffset", &self.ullAudioStreamOffset).field("wParam", &self.wParam).field("lParam", &self.lParam).field("ullAudioTimeOffset", &self.ullAudioTimeOffset).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPEVENTEX {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield && self.ulStreamNum == other.ulStreamNum && self.ullAudioStreamOffset == other.ullAudioStreamOffset && self.wParam == other.wParam && self.lParam == other.lParam && self.ullAudioTimeOffset == other.ullAudioTimeOffset
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPEVENTEX {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPEVENTEX {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPEVENTLPARAMTYPE(pub i32);
pub const SPET_LPARAM_IS_UNDEFINED: SPEVENTLPARAMTYPE = SPEVENTLPARAMTYPE(0i32);
pub const SPET_LPARAM_IS_TOKEN: SPEVENTLPARAMTYPE = SPEVENTLPARAMTYPE(1i32);
pub const SPET_LPARAM_IS_OBJECT: SPEVENTLPARAMTYPE = SPEVENTLPARAMTYPE(2i32);
pub const SPET_LPARAM_IS_POINTER: SPEVENTLPARAMTYPE = SPEVENTLPARAMTYPE(3i32);
pub const SPET_LPARAM_IS_STRING: SPEVENTLPARAMTYPE = SPEVENTLPARAMTYPE(4i32);
impl ::core::convert::From<i32> for SPEVENTLPARAMTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPEVENTLPARAMTYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPEVENTSOURCEINFO {
pub ullEventInterest: u64,
pub ullQueuedInterest: u64,
pub ulCount: u32,
}
impl SPEVENTSOURCEINFO {}
impl ::core::default::Default for SPEVENTSOURCEINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPEVENTSOURCEINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPEVENTSOURCEINFO").field("ullEventInterest", &self.ullEventInterest).field("ullQueuedInterest", &self.ullQueuedInterest).field("ulCount", &self.ulCount).finish()
}
}
impl ::core::cmp::PartialEq for SPEVENTSOURCEINFO {
fn eq(&self, other: &Self) -> bool {
self.ullEventInterest == other.ullEventInterest && self.ullQueuedInterest == other.ullQueuedInterest && self.ulCount == other.ulCount
}
}
impl ::core::cmp::Eq for SPEVENTSOURCEINFO {}
unsafe impl ::windows::core::Abi for SPEVENTSOURCEINFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPFILEMODE(pub i32);
pub const SPFM_OPEN_READONLY: SPFILEMODE = SPFILEMODE(0i32);
pub const SPFM_OPEN_READWRITE: SPFILEMODE = SPFILEMODE(1i32);
pub const SPFM_CREATE: SPFILEMODE = SPFILEMODE(2i32);
pub const SPFM_CREATE_ALWAYS: SPFILEMODE = SPFILEMODE(3i32);
pub const SPFM_NUM_MODES: SPFILEMODE = SPFILEMODE(4i32);
impl ::core::convert::From<i32> for SPFILEMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPFILEMODE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPGRAMMAROPTIONS(pub i32);
pub const SPGO_SAPI: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(1i32);
pub const SPGO_SRGS: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(2i32);
pub const SPGO_UPS: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(4i32);
pub const SPGO_SRGS_MS_SCRIPT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(8i32);
pub const SPGO_SRGS_W3C_SCRIPT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(256i32);
pub const SPGO_SRGS_STG_SCRIPT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(512i32);
pub const SPGO_SRGS_SCRIPT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(778i32);
pub const SPGO_FILE: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(16i32);
pub const SPGO_HTTP: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(32i32);
pub const SPGO_RES: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(64i32);
pub const SPGO_OBJECT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(128i32);
pub const SPGO_DEFAULT: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(1019i32);
pub const SPGO_ALL: SPGRAMMAROPTIONS = SPGRAMMAROPTIONS(1023i32);
impl ::core::convert::From<i32> for SPGRAMMAROPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPGRAMMAROPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPGRAMMARSTATE(pub i32);
pub const SPGS_DISABLED: SPGRAMMARSTATE = SPGRAMMARSTATE(0i32);
pub const SPGS_ENABLED: SPGRAMMARSTATE = SPGRAMMARSTATE(1i32);
pub const SPGS_EXCLUSIVE: SPGRAMMARSTATE = SPGRAMMARSTATE(3i32);
impl ::core::convert::From<i32> for SPGRAMMARSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPGRAMMARSTATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPGRAMMARWORDTYPE(pub i32);
pub const SPWT_DISPLAY: SPGRAMMARWORDTYPE = SPGRAMMARWORDTYPE(0i32);
pub const SPWT_LEXICAL: SPGRAMMARWORDTYPE = SPGRAMMARWORDTYPE(1i32);
pub const SPWT_PRONUNCIATION: SPGRAMMARWORDTYPE = SPGRAMMARWORDTYPE(2i32);
pub const SPWT_LEXICAL_NO_SPECIAL_CHARS: SPGRAMMARWORDTYPE = SPGRAMMARWORDTYPE(3i32);
impl ::core::convert::From<i32> for SPGRAMMARWORDTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPGRAMMARWORDTYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPINTERFERENCE(pub i32);
pub const SPINTERFERENCE_NONE: SPINTERFERENCE = SPINTERFERENCE(0i32);
pub const SPINTERFERENCE_NOISE: SPINTERFERENCE = SPINTERFERENCE(1i32);
pub const SPINTERFERENCE_NOSIGNAL: SPINTERFERENCE = SPINTERFERENCE(2i32);
pub const SPINTERFERENCE_TOOLOUD: SPINTERFERENCE = SPINTERFERENCE(3i32);
pub const SPINTERFERENCE_TOOQUIET: SPINTERFERENCE = SPINTERFERENCE(4i32);
pub const SPINTERFERENCE_TOOFAST: SPINTERFERENCE = SPINTERFERENCE(5i32);
pub const SPINTERFERENCE_TOOSLOW: SPINTERFERENCE = SPINTERFERENCE(6i32);
pub const SPINTERFERENCE_LATENCY_WARNING: SPINTERFERENCE = SPINTERFERENCE(7i32);
pub const SPINTERFERENCE_LATENCY_TRUNCATE_BEGIN: SPINTERFERENCE = SPINTERFERENCE(8i32);
pub const SPINTERFERENCE_LATENCY_TRUNCATE_END: SPINTERFERENCE = SPINTERFERENCE(9i32);
impl ::core::convert::From<i32> for SPINTERFERENCE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPINTERFERENCE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPLEXICONTYPE(pub i32);
pub const eLEXTYPE_USER: SPLEXICONTYPE = SPLEXICONTYPE(1i32);
pub const eLEXTYPE_APP: SPLEXICONTYPE = SPLEXICONTYPE(2i32);
pub const eLEXTYPE_VENDORLEXICON: SPLEXICONTYPE = SPLEXICONTYPE(4i32);
pub const eLEXTYPE_LETTERTOSOUND: SPLEXICONTYPE = SPLEXICONTYPE(8i32);
pub const eLEXTYPE_MORPHOLOGY: SPLEXICONTYPE = SPLEXICONTYPE(16i32);
pub const eLEXTYPE_RESERVED4: SPLEXICONTYPE = SPLEXICONTYPE(32i32);
pub const eLEXTYPE_USER_SHORTCUT: SPLEXICONTYPE = SPLEXICONTYPE(64i32);
pub const eLEXTYPE_RESERVED6: SPLEXICONTYPE = SPLEXICONTYPE(128i32);
pub const eLEXTYPE_RESERVED7: SPLEXICONTYPE = SPLEXICONTYPE(256i32);
pub const eLEXTYPE_RESERVED8: SPLEXICONTYPE = SPLEXICONTYPE(512i32);
pub const eLEXTYPE_RESERVED9: SPLEXICONTYPE = SPLEXICONTYPE(1024i32);
pub const eLEXTYPE_RESERVED10: SPLEXICONTYPE = SPLEXICONTYPE(2048i32);
pub const eLEXTYPE_PRIVATE1: SPLEXICONTYPE = SPLEXICONTYPE(4096i32);
pub const eLEXTYPE_PRIVATE2: SPLEXICONTYPE = SPLEXICONTYPE(8192i32);
pub const eLEXTYPE_PRIVATE3: SPLEXICONTYPE = SPLEXICONTYPE(16384i32);
pub const eLEXTYPE_PRIVATE4: SPLEXICONTYPE = SPLEXICONTYPE(32768i32);
pub const eLEXTYPE_PRIVATE5: SPLEXICONTYPE = SPLEXICONTYPE(65536i32);
pub const eLEXTYPE_PRIVATE6: SPLEXICONTYPE = SPLEXICONTYPE(131072i32);
pub const eLEXTYPE_PRIVATE7: SPLEXICONTYPE = SPLEXICONTYPE(262144i32);
pub const eLEXTYPE_PRIVATE8: SPLEXICONTYPE = SPLEXICONTYPE(524288i32);
pub const eLEXTYPE_PRIVATE9: SPLEXICONTYPE = SPLEXICONTYPE(1048576i32);
pub const eLEXTYPE_PRIVATE10: SPLEXICONTYPE = SPLEXICONTYPE(2097152i32);
pub const eLEXTYPE_PRIVATE11: SPLEXICONTYPE = SPLEXICONTYPE(4194304i32);
pub const eLEXTYPE_PRIVATE12: SPLEXICONTYPE = SPLEXICONTYPE(8388608i32);
pub const eLEXTYPE_PRIVATE13: SPLEXICONTYPE = SPLEXICONTYPE(16777216i32);
pub const eLEXTYPE_PRIVATE14: SPLEXICONTYPE = SPLEXICONTYPE(33554432i32);
pub const eLEXTYPE_PRIVATE15: SPLEXICONTYPE = SPLEXICONTYPE(67108864i32);
pub const eLEXTYPE_PRIVATE16: SPLEXICONTYPE = SPLEXICONTYPE(134217728i32);
pub const eLEXTYPE_PRIVATE17: SPLEXICONTYPE = SPLEXICONTYPE(268435456i32);
pub const eLEXTYPE_PRIVATE18: SPLEXICONTYPE = SPLEXICONTYPE(536870912i32);
pub const eLEXTYPE_PRIVATE19: SPLEXICONTYPE = SPLEXICONTYPE(1073741824i32);
pub const eLEXTYPE_PRIVATE20: SPLEXICONTYPE = SPLEXICONTYPE(-2147483648i32);
impl ::core::convert::From<i32> for SPLEXICONTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPLEXICONTYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPLOADOPTIONS(pub i32);
pub const SPLO_STATIC: SPLOADOPTIONS = SPLOADOPTIONS(0i32);
pub const SPLO_DYNAMIC: SPLOADOPTIONS = SPLOADOPTIONS(1i32);
impl ::core::convert::From<i32> for SPLOADOPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPLOADOPTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPMATCHINGMODE(pub i32);
pub const AllWords: SPMATCHINGMODE = SPMATCHINGMODE(0i32);
pub const Subsequence: SPMATCHINGMODE = SPMATCHINGMODE(1i32);
pub const OrderedSubset: SPMATCHINGMODE = SPMATCHINGMODE(3i32);
pub const SubsequenceContentRequired: SPMATCHINGMODE = SPMATCHINGMODE(5i32);
pub const OrderedSubsetContentRequired: SPMATCHINGMODE = SPMATCHINGMODE(7i32);
impl ::core::convert::From<i32> for SPMATCHINGMODE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPMATCHINGMODE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPNORMALIZATIONLIST {
pub ulSize: u32,
pub ppszzNormalizedList: *mut *mut u16,
}
impl SPNORMALIZATIONLIST {}
impl ::core::default::Default for SPNORMALIZATIONLIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPNORMALIZATIONLIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPNORMALIZATIONLIST").field("ulSize", &self.ulSize).field("ppszzNormalizedList", &self.ppszzNormalizedList).finish()
}
}
impl ::core::cmp::PartialEq for SPNORMALIZATIONLIST {
fn eq(&self, other: &Self) -> bool {
self.ulSize == other.ulSize && self.ppszzNormalizedList == other.ppszzNormalizedList
}
}
impl ::core::cmp::Eq for SPNORMALIZATIONLIST {}
unsafe impl ::windows::core::Abi for SPNORMALIZATIONLIST {
type Abi = Self;
}
#[cfg(feature = "Win32_Foundation")]
pub type SPNOTIFYCALLBACK = unsafe extern "system" fn(wparam: super::super::Foundation::WPARAM, lparam: super::super::Foundation::LPARAM);
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPPARTOFSPEECH(pub i32);
pub const SPPS_NotOverriden: SPPARTOFSPEECH = SPPARTOFSPEECH(-1i32);
pub const SPPS_Unknown: SPPARTOFSPEECH = SPPARTOFSPEECH(0i32);
pub const SPPS_Noun: SPPARTOFSPEECH = SPPARTOFSPEECH(4096i32);
pub const SPPS_Verb: SPPARTOFSPEECH = SPPARTOFSPEECH(8192i32);
pub const SPPS_Modifier: SPPARTOFSPEECH = SPPARTOFSPEECH(12288i32);
pub const SPPS_Function: SPPARTOFSPEECH = SPPARTOFSPEECH(16384i32);
pub const SPPS_Interjection: SPPARTOFSPEECH = SPPARTOFSPEECH(20480i32);
pub const SPPS_Noncontent: SPPARTOFSPEECH = SPPARTOFSPEECH(24576i32);
pub const SPPS_LMA: SPPARTOFSPEECH = SPPARTOFSPEECH(28672i32);
pub const SPPS_SuppressWord: SPPARTOFSPEECH = SPPARTOFSPEECH(61440i32);
impl ::core::convert::From<i32> for SPPARTOFSPEECH {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPPARTOFSPEECH {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub struct SPPHRASE {
pub __AnonymousBase_sapi53_L5821_C34: SPPHRASE_50,
pub pSML: super::super::Foundation::PWSTR,
pub pSemanticErrorInfo: *mut SPSEMANTICERRORINFO,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPHRASE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPHRASE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::fmt::Debug for SPPHRASE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPPHRASE").field("__AnonymousBase_sapi53_L5821_C34", &self.__AnonymousBase_sapi53_L5821_C34).field("pSML", &self.pSML).field("pSemanticErrorInfo", &self.pSemanticErrorInfo).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPHRASE {
fn eq(&self, other: &Self) -> bool {
self.__AnonymousBase_sapi53_L5821_C34 == other.__AnonymousBase_sapi53_L5821_C34 && self.pSML == other.pSML && self.pSemanticErrorInfo == other.pSemanticErrorInfo
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPHRASE {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPHRASE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPPHRASEELEMENT {
pub ulAudioTimeOffset: u32,
pub ulAudioSizeTime: u32,
pub ulAudioStreamOffset: u32,
pub ulAudioSizeBytes: u32,
pub ulRetainedStreamOffset: u32,
pub ulRetainedSizeBytes: u32,
pub pszDisplayText: super::super::Foundation::PWSTR,
pub pszLexicalForm: super::super::Foundation::PWSTR,
pub pszPronunciation: *mut u16,
pub bDisplayAttributes: u8,
pub RequiredConfidence: i8,
pub ActualConfidence: i8,
pub Reserved: u8,
pub SREngineConfidence: f32,
}
#[cfg(feature = "Win32_Foundation")]
impl SPPHRASEELEMENT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPPHRASEELEMENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPPHRASEELEMENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPPHRASEELEMENT")
.field("ulAudioTimeOffset", &self.ulAudioTimeOffset)
.field("ulAudioSizeTime", &self.ulAudioSizeTime)
.field("ulAudioStreamOffset", &self.ulAudioStreamOffset)
.field("ulAudioSizeBytes", &self.ulAudioSizeBytes)
.field("ulRetainedStreamOffset", &self.ulRetainedStreamOffset)
.field("ulRetainedSizeBytes", &self.ulRetainedSizeBytes)
.field("pszDisplayText", &self.pszDisplayText)
.field("pszLexicalForm", &self.pszLexicalForm)
.field("pszPronunciation", &self.pszPronunciation)
.field("bDisplayAttributes", &self.bDisplayAttributes)
.field("RequiredConfidence", &self.RequiredConfidence)
.field("ActualConfidence", &self.ActualConfidence)
.field("Reserved", &self.Reserved)
.field("SREngineConfidence", &self.SREngineConfidence)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPPHRASEELEMENT {
fn eq(&self, other: &Self) -> bool {
self.ulAudioTimeOffset == other.ulAudioTimeOffset
&& self.ulAudioSizeTime == other.ulAudioSizeTime
&& self.ulAudioStreamOffset == other.ulAudioStreamOffset
&& self.ulAudioSizeBytes == other.ulAudioSizeBytes
&& self.ulRetainedStreamOffset == other.ulRetainedStreamOffset
&& self.ulRetainedSizeBytes == other.ulRetainedSizeBytes
&& self.pszDisplayText == other.pszDisplayText
&& self.pszLexicalForm == other.pszLexicalForm
&& self.pszPronunciation == other.pszPronunciation
&& self.bDisplayAttributes == other.bDisplayAttributes
&& self.RequiredConfidence == other.RequiredConfidence
&& self.ActualConfidence == other.ActualConfidence
&& self.Reserved == other.Reserved
&& self.SREngineConfidence == other.SREngineConfidence
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPPHRASEELEMENT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPPHRASEELEMENT {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::clone::Clone for SPPHRASEPROPERTY {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub struct SPPHRASEPROPERTY {
pub pszName: super::super::Foundation::PWSTR,
pub Anonymous: SPPHRASEPROPERTY_0,
pub pszValue: super::super::Foundation::PWSTR,
pub vValue: super::super::System::Com::VARIANT,
pub ulFirstElement: u32,
pub ulCountOfElements: u32,
pub pNextSibling: *mut SPPHRASEPROPERTY,
pub pFirstChild: *mut SPPHRASEPROPERTY,
pub SREngineConfidence: f32,
pub Confidence: i8,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPHRASEPROPERTY {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPHRASEPROPERTY {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPHRASEPROPERTY {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPHRASEPROPERTY {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPHRASEPROPERTY {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub union SPPHRASEPROPERTY_0 {
pub ulId: u32,
pub Anonymous: SPPHRASEPROPERTY_0_0,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPHRASEPROPERTY_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPHRASEPROPERTY_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPHRASEPROPERTY_0 {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPHRASEPROPERTY_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPHRASEPROPERTY_0 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub struct SPPHRASEPROPERTY_0_0 {
pub bType: u8,
pub bReserved: u8,
pub usArrayIndex: u16,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPHRASEPROPERTY_0_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPHRASEPROPERTY_0_0 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::fmt::Debug for SPPHRASEPROPERTY_0_0 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("_Anonymous_e__Struct").field("bType", &self.bType).field("bReserved", &self.bReserved).field("usArrayIndex", &self.usArrayIndex).finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPHRASEPROPERTY_0_0 {
fn eq(&self, other: &Self) -> bool {
self.bType == other.bType && self.bReserved == other.bReserved && self.usArrayIndex == other.usArrayIndex
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPHRASEPROPERTY_0_0 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPHRASEPROPERTY_0_0 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPPHRASEPROPERTYUNIONTYPE(pub i32);
pub const SPPPUT_UNUSED: SPPHRASEPROPERTYUNIONTYPE = SPPHRASEPROPERTYUNIONTYPE(0i32);
pub const SPPPUT_ARRAY_INDEX: SPPHRASEPROPERTYUNIONTYPE = SPPHRASEPROPERTYUNIONTYPE(1i32);
impl ::core::convert::From<i32> for SPPHRASEPROPERTYUNIONTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPPHRASEPROPERTYUNIONTYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPPHRASEREPLACEMENT {
pub bDisplayAttributes: u8,
pub pszReplacementText: super::super::Foundation::PWSTR,
pub ulFirstElement: u32,
pub ulCountOfElements: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl SPPHRASEREPLACEMENT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPPHRASEREPLACEMENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPPHRASEREPLACEMENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPPHRASEREPLACEMENT").field("bDisplayAttributes", &self.bDisplayAttributes).field("pszReplacementText", &self.pszReplacementText).field("ulFirstElement", &self.ulFirstElement).field("ulCountOfElements", &self.ulCountOfElements).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPPHRASEREPLACEMENT {
fn eq(&self, other: &Self) -> bool {
self.bDisplayAttributes == other.bDisplayAttributes && self.pszReplacementText == other.pszReplacementText && self.ulFirstElement == other.ulFirstElement && self.ulCountOfElements == other.ulCountOfElements
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPPHRASEREPLACEMENT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPPHRASEREPLACEMENT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPPHRASERNG(pub i32);
pub const SPPR_ALL_ELEMENTS: SPPHRASERNG = SPPHRASERNG(-1i32);
impl ::core::convert::From<i32> for SPPHRASERNG {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPPHRASERNG {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPPHRASERULE {
pub pszName: super::super::Foundation::PWSTR,
pub ulId: u32,
pub ulFirstElement: u32,
pub ulCountOfElements: u32,
pub pNextSibling: *mut SPPHRASERULE,
pub pFirstChild: *mut SPPHRASERULE,
pub SREngineConfidence: f32,
pub Confidence: i8,
}
#[cfg(feature = "Win32_Foundation")]
impl SPPHRASERULE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPPHRASERULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPPHRASERULE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPPHRASERULE")
.field("pszName", &self.pszName)
.field("ulId", &self.ulId)
.field("ulFirstElement", &self.ulFirstElement)
.field("ulCountOfElements", &self.ulCountOfElements)
.field("pNextSibling", &self.pNextSibling)
.field("pFirstChild", &self.pFirstChild)
.field("SREngineConfidence", &self.SREngineConfidence)
.field("Confidence", &self.Confidence)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPPHRASERULE {
fn eq(&self, other: &Self) -> bool {
self.pszName == other.pszName && self.ulId == other.ulId && self.ulFirstElement == other.ulFirstElement && self.ulCountOfElements == other.ulCountOfElements && self.pNextSibling == other.pNextSibling && self.pFirstChild == other.pFirstChild && self.SREngineConfidence == other.SREngineConfidence && self.Confidence == other.Confidence
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPPHRASERULE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPPHRASERULE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub struct SPPHRASE_50 {
pub cbSize: u32,
pub LangID: u16,
pub wHomophoneGroupId: u16,
pub ullGrammarID: u64,
pub ftStartTime: u64,
pub ullAudioStreamPosition: u64,
pub ulAudioSizeBytes: u32,
pub ulRetainedSizeBytes: u32,
pub ulAudioSizeTime: u32,
pub Rule: SPPHRASERULE,
pub pProperties: *mut SPPHRASEPROPERTY,
pub pElements: *mut SPPHRASEELEMENT,
pub cReplacements: u32,
pub pReplacements: *mut SPPHRASEREPLACEMENT,
pub SREngineID: ::windows::core::GUID,
pub ulSREnginePrivateDataSize: u32,
pub pSREnginePrivateData: *mut u8,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPHRASE_50 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPHRASE_50 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::fmt::Debug for SPPHRASE_50 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPPHRASE_50")
.field("cbSize", &self.cbSize)
.field("LangID", &self.LangID)
.field("wHomophoneGroupId", &self.wHomophoneGroupId)
.field("ullGrammarID", &self.ullGrammarID)
.field("ftStartTime", &self.ftStartTime)
.field("ullAudioStreamPosition", &self.ullAudioStreamPosition)
.field("ulAudioSizeBytes", &self.ulAudioSizeBytes)
.field("ulRetainedSizeBytes", &self.ulRetainedSizeBytes)
.field("ulAudioSizeTime", &self.ulAudioSizeTime)
.field("Rule", &self.Rule)
.field("pProperties", &self.pProperties)
.field("pElements", &self.pElements)
.field("cReplacements", &self.cReplacements)
.field("pReplacements", &self.pReplacements)
.field("SREngineID", &self.SREngineID)
.field("ulSREnginePrivateDataSize", &self.ulSREnginePrivateDataSize)
.field("pSREnginePrivateData", &self.pSREnginePrivateData)
.finish()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPHRASE_50 {
fn eq(&self, other: &Self) -> bool {
self.cbSize == other.cbSize
&& self.LangID == other.LangID
&& self.wHomophoneGroupId == other.wHomophoneGroupId
&& self.ullGrammarID == other.ullGrammarID
&& self.ftStartTime == other.ftStartTime
&& self.ullAudioStreamPosition == other.ullAudioStreamPosition
&& self.ulAudioSizeBytes == other.ulAudioSizeBytes
&& self.ulRetainedSizeBytes == other.ulRetainedSizeBytes
&& self.ulAudioSizeTime == other.ulAudioSizeTime
&& self.Rule == other.Rule
&& self.pProperties == other.pProperties
&& self.pElements == other.pElements
&& self.cReplacements == other.cReplacements
&& self.pReplacements == other.pReplacements
&& self.SREngineID == other.SREngineID
&& self.ulSREnginePrivateDataSize == other.ulSREnginePrivateDataSize
&& self.pSREnginePrivateData == other.pSREnginePrivateData
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPHRASE_50 {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPHRASE_50 {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPPRONUNCIATIONFLAGS(pub i32);
pub const ePRONFLAG_USED: SPPRONUNCIATIONFLAGS = SPPRONUNCIATIONFLAGS(1i32);
impl ::core::convert::From<i32> for SPPRONUNCIATIONFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPPRONUNCIATIONFLAGS {
type Abi = Self;
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::clone::Clone for SPPROPERTYINFO {
fn clone(&self) -> Self {
unimplemented!()
}
}
#[repr(C)]
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub struct SPPROPERTYINFO {
pub pszName: super::super::Foundation::PWSTR,
pub ulId: u32,
pub pszValue: super::super::Foundation::PWSTR,
pub vValue: super::super::System::Com::VARIANT,
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl SPPROPERTYINFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::default::Default for SPPROPERTYINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::PartialEq for SPPROPERTYINFO {
fn eq(&self, _other: &Self) -> bool {
unimplemented!()
}
}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
impl ::core::cmp::Eq for SPPROPERTYINFO {}
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
unsafe impl ::windows::core::Abi for SPPROPERTYINFO {
type Abi = ::core::mem::ManuallyDrop<Self>;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPRECOCONTEXTSTATUS {
pub eInterference: SPINTERFERENCE,
pub szRequestTypeOfUI: [u16; 255],
pub dwReserved1: u32,
pub dwReserved2: u32,
}
impl SPRECOCONTEXTSTATUS {}
impl ::core::default::Default for SPRECOCONTEXTSTATUS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPRECOCONTEXTSTATUS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPRECOCONTEXTSTATUS").field("eInterference", &self.eInterference).field("szRequestTypeOfUI", &self.szRequestTypeOfUI).field("dwReserved1", &self.dwReserved1).field("dwReserved2", &self.dwReserved2).finish()
}
}
impl ::core::cmp::PartialEq for SPRECOCONTEXTSTATUS {
fn eq(&self, other: &Self) -> bool {
self.eInterference == other.eInterference && self.szRequestTypeOfUI == other.szRequestTypeOfUI && self.dwReserved1 == other.dwReserved1 && self.dwReserved2 == other.dwReserved2
}
}
impl ::core::cmp::Eq for SPRECOCONTEXTSTATUS {}
unsafe impl ::windows::core::Abi for SPRECOCONTEXTSTATUS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPRECOEVENTFLAGS(pub i32);
pub const SPREF_AutoPause: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(1i32);
pub const SPREF_Emulated: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(2i32);
pub const SPREF_SMLTimeout: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(4i32);
pub const SPREF_ExtendableParse: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(8i32);
pub const SPREF_ReSent: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(16i32);
pub const SPREF_Hypothesis: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(32i32);
pub const SPREF_FalseRecognition: SPRECOEVENTFLAGS = SPRECOEVENTFLAGS(64i32);
impl ::core::convert::From<i32> for SPRECOEVENTFLAGS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPRECOEVENTFLAGS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPRECOGNIZERSTATUS {
pub AudioStatus: SPAUDIOSTATUS,
pub ullRecognitionStreamPos: u64,
pub ulStreamNumber: u32,
pub ulNumActive: u32,
pub clsidEngine: ::windows::core::GUID,
pub cLangIDs: u32,
pub aLangID: [u16; 20],
pub ullRecognitionStreamTime: u64,
}
impl SPRECOGNIZERSTATUS {}
impl ::core::default::Default for SPRECOGNIZERSTATUS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPRECOGNIZERSTATUS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPRECOGNIZERSTATUS")
.field("AudioStatus", &self.AudioStatus)
.field("ullRecognitionStreamPos", &self.ullRecognitionStreamPos)
.field("ulStreamNumber", &self.ulStreamNumber)
.field("ulNumActive", &self.ulNumActive)
.field("clsidEngine", &self.clsidEngine)
.field("cLangIDs", &self.cLangIDs)
.field("aLangID", &self.aLangID)
.field("ullRecognitionStreamTime", &self.ullRecognitionStreamTime)
.finish()
}
}
impl ::core::cmp::PartialEq for SPRECOGNIZERSTATUS {
fn eq(&self, other: &Self) -> bool {
self.AudioStatus == other.AudioStatus && self.ullRecognitionStreamPos == other.ullRecognitionStreamPos && self.ulStreamNumber == other.ulStreamNumber && self.ulNumActive == other.ulNumActive && self.clsidEngine == other.clsidEngine && self.cLangIDs == other.cLangIDs && self.aLangID == other.aLangID && self.ullRecognitionStreamTime == other.ullRecognitionStreamTime
}
}
impl ::core::cmp::Eq for SPRECOGNIZERSTATUS {}
unsafe impl ::windows::core::Abi for SPRECOGNIZERSTATUS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPRECORESULTTIMES {
pub ftStreamTime: super::super::Foundation::FILETIME,
pub ullLength: u64,
pub dwTickCount: u32,
pub ullStart: u64,
}
#[cfg(feature = "Win32_Foundation")]
impl SPRECORESULTTIMES {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPRECORESULTTIMES {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPRECORESULTTIMES {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPRECORESULTTIMES").field("ftStreamTime", &self.ftStreamTime).field("ullLength", &self.ullLength).field("dwTickCount", &self.dwTickCount).field("ullStart", &self.ullStart).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPRECORESULTTIMES {
fn eq(&self, other: &Self) -> bool {
self.ftStreamTime == other.ftStreamTime && self.ullLength == other.ullLength && self.dwTickCount == other.dwTickCount && self.ullStart == other.ullStart
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPRECORESULTTIMES {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPRECORESULTTIMES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPRECOSTATE(pub i32);
pub const SPRST_INACTIVE: SPRECOSTATE = SPRECOSTATE(0i32);
pub const SPRST_ACTIVE: SPRECOSTATE = SPRECOSTATE(1i32);
pub const SPRST_ACTIVE_ALWAYS: SPRECOSTATE = SPRECOSTATE(2i32);
pub const SPRST_INACTIVE_WITH_PURGE: SPRECOSTATE = SPRECOSTATE(3i32);
pub const SPRST_NUM_STATES: SPRECOSTATE = SPRECOSTATE(4i32);
impl ::core::convert::From<i32> for SPRECOSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPRECOSTATE {
type Abi = Self;
}
pub const SPRP_NORMAL: u32 = 0u32;
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPRULE {
pub pszRuleName: super::super::Foundation::PWSTR,
pub ulRuleId: u32,
pub dwAttributes: u32,
}
#[cfg(feature = "Win32_Foundation")]
impl SPRULE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPRULE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPRULE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPRULE").field("pszRuleName", &self.pszRuleName).field("ulRuleId", &self.ulRuleId).field("dwAttributes", &self.dwAttributes).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPRULE {
fn eq(&self, other: &Self) -> bool {
self.pszRuleName == other.pszRuleName && self.ulRuleId == other.ulRuleId && self.dwAttributes == other.dwAttributes
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPRULE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPRULE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPRULESTATE(pub i32);
pub const SPRS_INACTIVE: SPRULESTATE = SPRULESTATE(0i32);
pub const SPRS_ACTIVE: SPRULESTATE = SPRULESTATE(1i32);
pub const SPRS_ACTIVE_WITH_AUTO_PAUSE: SPRULESTATE = SPRULESTATE(3i32);
pub const SPRS_ACTIVE_USER_DELIMITED: SPRULESTATE = SPRULESTATE(4i32);
impl ::core::convert::From<i32> for SPRULESTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPRULESTATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPRUNSTATE(pub i32);
pub const SPRS_DONE: SPRUNSTATE = SPRUNSTATE(1i32);
pub const SPRS_IS_SPEAKING: SPRUNSTATE = SPRUNSTATE(2i32);
impl ::core::convert::From<i32> for SPRUNSTATE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPRUNSTATE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPSEMANTICERRORINFO {
pub ulLineNumber: u32,
pub pszScriptLine: super::super::Foundation::PWSTR,
pub pszSource: super::super::Foundation::PWSTR,
pub pszDescription: super::super::Foundation::PWSTR,
pub hrResultCode: ::windows::core::HRESULT,
}
#[cfg(feature = "Win32_Foundation")]
impl SPSEMANTICERRORINFO {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPSEMANTICERRORINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPSEMANTICERRORINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSEMANTICERRORINFO").field("ulLineNumber", &self.ulLineNumber).field("pszScriptLine", &self.pszScriptLine).field("pszSource", &self.pszSource).field("pszDescription", &self.pszDescription).field("hrResultCode", &self.hrResultCode).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPSEMANTICERRORINFO {
fn eq(&self, other: &Self) -> bool {
self.ulLineNumber == other.ulLineNumber && self.pszScriptLine == other.pszScriptLine && self.pszSource == other.pszSource && self.pszDescription == other.pszDescription && self.hrResultCode == other.hrResultCode
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPSEMANTICERRORINFO {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPSEMANTICERRORINFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPSEMANTICFORMAT(pub i32);
pub const SPSMF_SAPI_PROPERTIES: SPSEMANTICFORMAT = SPSEMANTICFORMAT(0i32);
pub const SPSMF_SRGS_SEMANTICINTERPRETATION_MS: SPSEMANTICFORMAT = SPSEMANTICFORMAT(1i32);
pub const SPSMF_SRGS_SAPIPROPERTIES: SPSEMANTICFORMAT = SPSEMANTICFORMAT(2i32);
pub const SPSMF_UPS: SPSEMANTICFORMAT = SPSEMANTICFORMAT(4i32);
pub const SPSMF_SRGS_SEMANTICINTERPRETATION_W3C: SPSEMANTICFORMAT = SPSEMANTICFORMAT(8i32);
impl ::core::convert::From<i32> for SPSEMANTICFORMAT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPSEMANTICFORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPSERIALIZEDEVENT {
pub _bitfield: i32,
pub ulStreamNum: u32,
pub ullAudioStreamOffset: u64,
pub SerializedwParam: u32,
pub SerializedlParam: i32,
}
impl SPSERIALIZEDEVENT {}
impl ::core::default::Default for SPSERIALIZEDEVENT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPSERIALIZEDEVENT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSERIALIZEDEVENT").field("_bitfield", &self._bitfield).field("ulStreamNum", &self.ulStreamNum).field("ullAudioStreamOffset", &self.ullAudioStreamOffset).field("SerializedwParam", &self.SerializedwParam).field("SerializedlParam", &self.SerializedlParam).finish()
}
}
impl ::core::cmp::PartialEq for SPSERIALIZEDEVENT {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield && self.ulStreamNum == other.ulStreamNum && self.ullAudioStreamOffset == other.ullAudioStreamOffset && self.SerializedwParam == other.SerializedwParam && self.SerializedlParam == other.SerializedlParam
}
}
impl ::core::cmp::Eq for SPSERIALIZEDEVENT {}
unsafe impl ::windows::core::Abi for SPSERIALIZEDEVENT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPSERIALIZEDEVENT64 {
pub _bitfield: i32,
pub ulStreamNum: u32,
pub ullAudioStreamOffset: u64,
pub SerializedwParam: u64,
pub SerializedlParam: i64,
}
impl SPSERIALIZEDEVENT64 {}
impl ::core::default::Default for SPSERIALIZEDEVENT64 {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPSERIALIZEDEVENT64 {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSERIALIZEDEVENT64").field("_bitfield", &self._bitfield).field("ulStreamNum", &self.ulStreamNum).field("ullAudioStreamOffset", &self.ullAudioStreamOffset).field("SerializedwParam", &self.SerializedwParam).field("SerializedlParam", &self.SerializedlParam).finish()
}
}
impl ::core::cmp::PartialEq for SPSERIALIZEDEVENT64 {
fn eq(&self, other: &Self) -> bool {
self._bitfield == other._bitfield && self.ulStreamNum == other.ulStreamNum && self.ullAudioStreamOffset == other.ullAudioStreamOffset && self.SerializedwParam == other.SerializedwParam && self.SerializedlParam == other.SerializedlParam
}
}
impl ::core::cmp::Eq for SPSERIALIZEDEVENT64 {}
unsafe impl ::windows::core::Abi for SPSERIALIZEDEVENT64 {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPSERIALIZEDPHRASE {
pub ulSerializedSize: u32,
}
impl SPSERIALIZEDPHRASE {}
impl ::core::default::Default for SPSERIALIZEDPHRASE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPSERIALIZEDPHRASE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSERIALIZEDPHRASE").field("ulSerializedSize", &self.ulSerializedSize).finish()
}
}
impl ::core::cmp::PartialEq for SPSERIALIZEDPHRASE {
fn eq(&self, other: &Self) -> bool {
self.ulSerializedSize == other.ulSerializedSize
}
}
impl ::core::cmp::Eq for SPSERIALIZEDPHRASE {}
unsafe impl ::windows::core::Abi for SPSERIALIZEDPHRASE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPSERIALIZEDRESULT {
pub ulSerializedSize: u32,
}
impl SPSERIALIZEDRESULT {}
impl ::core::default::Default for SPSERIALIZEDRESULT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPSERIALIZEDRESULT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSERIALIZEDRESULT").field("ulSerializedSize", &self.ulSerializedSize).finish()
}
}
impl ::core::cmp::PartialEq for SPSERIALIZEDRESULT {
fn eq(&self, other: &Self) -> bool {
self.ulSerializedSize == other.ulSerializedSize
}
}
impl ::core::cmp::Eq for SPSERIALIZEDRESULT {}
unsafe impl ::windows::core::Abi for SPSERIALIZEDRESULT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPSHORTCUTPAIR {
pub pNextSHORTCUTPAIR: *mut SPSHORTCUTPAIR,
pub LangID: u16,
pub shType: SPSHORTCUTTYPE,
pub pszDisplay: super::super::Foundation::PWSTR,
pub pszSpoken: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl SPSHORTCUTPAIR {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPSHORTCUTPAIR {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPSHORTCUTPAIR {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSHORTCUTPAIR").field("pNextSHORTCUTPAIR", &self.pNextSHORTCUTPAIR).field("LangID", &self.LangID).field("shType", &self.shType).field("pszDisplay", &self.pszDisplay).field("pszSpoken", &self.pszSpoken).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPSHORTCUTPAIR {
fn eq(&self, other: &Self) -> bool {
self.pNextSHORTCUTPAIR == other.pNextSHORTCUTPAIR && self.LangID == other.LangID && self.shType == other.shType && self.pszDisplay == other.pszDisplay && self.pszSpoken == other.pszSpoken
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPSHORTCUTPAIR {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPSHORTCUTPAIR {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPSHORTCUTPAIRLIST {
pub ulSize: u32,
pub pvBuffer: *mut u8,
pub pFirstShortcutPair: *mut SPSHORTCUTPAIR,
}
#[cfg(feature = "Win32_Foundation")]
impl SPSHORTCUTPAIRLIST {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPSHORTCUTPAIRLIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPSHORTCUTPAIRLIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSHORTCUTPAIRLIST").field("ulSize", &self.ulSize).field("pvBuffer", &self.pvBuffer).field("pFirstShortcutPair", &self.pFirstShortcutPair).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPSHORTCUTPAIRLIST {
fn eq(&self, other: &Self) -> bool {
self.ulSize == other.ulSize && self.pvBuffer == other.pvBuffer && self.pFirstShortcutPair == other.pFirstShortcutPair
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPSHORTCUTPAIRLIST {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPSHORTCUTPAIRLIST {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPSHORTCUTTYPE(pub i32);
pub const SPSHT_NotOverriden: SPSHORTCUTTYPE = SPSHORTCUTTYPE(-1i32);
pub const SPSHT_Unknown: SPSHORTCUTTYPE = SPSHORTCUTTYPE(0i32);
pub const SPSHT_EMAIL: SPSHORTCUTTYPE = SPSHORTCUTTYPE(4096i32);
pub const SPSHT_OTHER: SPSHORTCUTTYPE = SPSHORTCUTTYPE(8192i32);
pub const SPPS_RESERVED1: SPSHORTCUTTYPE = SPSHORTCUTTYPE(12288i32);
pub const SPPS_RESERVED2: SPSHORTCUTTYPE = SPSHORTCUTTYPE(16384i32);
pub const SPPS_RESERVED3: SPSHORTCUTTYPE = SPSHORTCUTTYPE(20480i32);
pub const SPPS_RESERVED4: SPSHORTCUTTYPE = SPSHORTCUTTYPE(61440i32);
impl ::core::convert::From<i32> for SPSHORTCUTTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPSHORTCUTTYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPSTATEHANDLE__ {
pub unused: i32,
}
impl SPSTATEHANDLE__ {}
impl ::core::default::Default for SPSTATEHANDLE__ {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPSTATEHANDLE__ {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPSTATEHANDLE__").field("unused", &self.unused).finish()
}
}
impl ::core::cmp::PartialEq for SPSTATEHANDLE__ {
fn eq(&self, other: &Self) -> bool {
self.unused == other.unused
}
}
impl ::core::cmp::Eq for SPSTATEHANDLE__ {}
unsafe impl ::windows::core::Abi for SPSTATEHANDLE__ {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPSTREAMFORMAT(pub i32);
pub const SPSF_Default: SPSTREAMFORMAT = SPSTREAMFORMAT(-1i32);
pub const SPSF_NoAssignedFormat: SPSTREAMFORMAT = SPSTREAMFORMAT(0i32);
pub const SPSF_Text: SPSTREAMFORMAT = SPSTREAMFORMAT(1i32);
pub const SPSF_NonStandardFormat: SPSTREAMFORMAT = SPSTREAMFORMAT(2i32);
pub const SPSF_ExtendedAudioFormat: SPSTREAMFORMAT = SPSTREAMFORMAT(3i32);
pub const SPSF_8kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(4i32);
pub const SPSF_8kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(5i32);
pub const SPSF_8kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(6i32);
pub const SPSF_8kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(7i32);
pub const SPSF_11kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(8i32);
pub const SPSF_11kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(9i32);
pub const SPSF_11kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(10i32);
pub const SPSF_11kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(11i32);
pub const SPSF_12kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(12i32);
pub const SPSF_12kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(13i32);
pub const SPSF_12kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(14i32);
pub const SPSF_12kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(15i32);
pub const SPSF_16kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(16i32);
pub const SPSF_16kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(17i32);
pub const SPSF_16kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(18i32);
pub const SPSF_16kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(19i32);
pub const SPSF_22kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(20i32);
pub const SPSF_22kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(21i32);
pub const SPSF_22kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(22i32);
pub const SPSF_22kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(23i32);
pub const SPSF_24kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(24i32);
pub const SPSF_24kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(25i32);
pub const SPSF_24kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(26i32);
pub const SPSF_24kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(27i32);
pub const SPSF_32kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(28i32);
pub const SPSF_32kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(29i32);
pub const SPSF_32kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(30i32);
pub const SPSF_32kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(31i32);
pub const SPSF_44kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(32i32);
pub const SPSF_44kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(33i32);
pub const SPSF_44kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(34i32);
pub const SPSF_44kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(35i32);
pub const SPSF_48kHz8BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(36i32);
pub const SPSF_48kHz8BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(37i32);
pub const SPSF_48kHz16BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(38i32);
pub const SPSF_48kHz16BitStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(39i32);
pub const SPSF_TrueSpeech_8kHz1BitMono: SPSTREAMFORMAT = SPSTREAMFORMAT(40i32);
pub const SPSF_CCITT_ALaw_8kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(41i32);
pub const SPSF_CCITT_ALaw_8kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(42i32);
pub const SPSF_CCITT_ALaw_11kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(43i32);
pub const SPSF_CCITT_ALaw_11kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(44i32);
pub const SPSF_CCITT_ALaw_22kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(45i32);
pub const SPSF_CCITT_ALaw_22kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(46i32);
pub const SPSF_CCITT_ALaw_44kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(47i32);
pub const SPSF_CCITT_ALaw_44kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(48i32);
pub const SPSF_CCITT_uLaw_8kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(49i32);
pub const SPSF_CCITT_uLaw_8kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(50i32);
pub const SPSF_CCITT_uLaw_11kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(51i32);
pub const SPSF_CCITT_uLaw_11kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(52i32);
pub const SPSF_CCITT_uLaw_22kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(53i32);
pub const SPSF_CCITT_uLaw_22kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(54i32);
pub const SPSF_CCITT_uLaw_44kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(55i32);
pub const SPSF_CCITT_uLaw_44kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(56i32);
pub const SPSF_ADPCM_8kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(57i32);
pub const SPSF_ADPCM_8kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(58i32);
pub const SPSF_ADPCM_11kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(59i32);
pub const SPSF_ADPCM_11kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(60i32);
pub const SPSF_ADPCM_22kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(61i32);
pub const SPSF_ADPCM_22kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(62i32);
pub const SPSF_ADPCM_44kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(63i32);
pub const SPSF_ADPCM_44kHzStereo: SPSTREAMFORMAT = SPSTREAMFORMAT(64i32);
pub const SPSF_GSM610_8kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(65i32);
pub const SPSF_GSM610_11kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(66i32);
pub const SPSF_GSM610_22kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(67i32);
pub const SPSF_GSM610_44kHzMono: SPSTREAMFORMAT = SPSTREAMFORMAT(68i32);
pub const SPSF_NUM_FORMATS: SPSTREAMFORMAT = SPSTREAMFORMAT(69i32);
impl ::core::convert::From<i32> for SPSTREAMFORMAT {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPSTREAMFORMAT {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPTEXTSELECTIONINFO {
pub ulStartActiveOffset: u32,
pub cchActiveChars: u32,
pub ulStartSelection: u32,
pub cchSelection: u32,
}
impl SPTEXTSELECTIONINFO {}
impl ::core::default::Default for SPTEXTSELECTIONINFO {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPTEXTSELECTIONINFO {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPTEXTSELECTIONINFO").field("ulStartActiveOffset", &self.ulStartActiveOffset).field("cchActiveChars", &self.cchActiveChars).field("ulStartSelection", &self.ulStartSelection).field("cchSelection", &self.cchSelection).finish()
}
}
impl ::core::cmp::PartialEq for SPTEXTSELECTIONINFO {
fn eq(&self, other: &Self) -> bool {
self.ulStartActiveOffset == other.ulStartActiveOffset && self.cchActiveChars == other.cchActiveChars && self.ulStartSelection == other.ulStartSelection && self.cchSelection == other.cchSelection
}
}
impl ::core::cmp::Eq for SPTEXTSELECTIONINFO {}
unsafe impl ::windows::core::Abi for SPTEXTSELECTIONINFO {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVACTIONS(pub i32);
pub const SPVA_Speak: SPVACTIONS = SPVACTIONS(0i32);
pub const SPVA_Silence: SPVACTIONS = SPVACTIONS(1i32);
pub const SPVA_Pronounce: SPVACTIONS = SPVACTIONS(2i32);
pub const SPVA_Bookmark: SPVACTIONS = SPVACTIONS(3i32);
pub const SPVA_SpellOut: SPVACTIONS = SPVACTIONS(4i32);
pub const SPVA_Section: SPVACTIONS = SPVACTIONS(5i32);
pub const SPVA_ParseUnknownTag: SPVACTIONS = SPVACTIONS(6i32);
impl ::core::convert::From<i32> for SPVACTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVACTIONS {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVALUETYPE(pub i32);
pub const SPDF_PROPERTY: SPVALUETYPE = SPVALUETYPE(1i32);
pub const SPDF_REPLACEMENT: SPVALUETYPE = SPVALUETYPE(2i32);
pub const SPDF_RULE: SPVALUETYPE = SPVALUETYPE(4i32);
pub const SPDF_DISPLAYTEXT: SPVALUETYPE = SPVALUETYPE(8i32);
pub const SPDF_LEXICALFORM: SPVALUETYPE = SPVALUETYPE(16i32);
pub const SPDF_PRONUNCIATION: SPVALUETYPE = SPVALUETYPE(32i32);
pub const SPDF_AUDIO: SPVALUETYPE = SPVALUETYPE(64i32);
pub const SPDF_ALTERNATES: SPVALUETYPE = SPVALUETYPE(128i32);
pub const SPDF_ALL: SPVALUETYPE = SPVALUETYPE(255i32);
impl ::core::convert::From<i32> for SPVALUETYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVALUETYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPVCONTEXT {
pub pCategory: super::super::Foundation::PWSTR,
pub pBefore: super::super::Foundation::PWSTR,
pub pAfter: super::super::Foundation::PWSTR,
}
#[cfg(feature = "Win32_Foundation")]
impl SPVCONTEXT {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPVCONTEXT {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPVCONTEXT {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPVCONTEXT").field("pCategory", &self.pCategory).field("pBefore", &self.pBefore).field("pAfter", &self.pAfter).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPVCONTEXT {
fn eq(&self, other: &Self) -> bool {
self.pCategory == other.pCategory && self.pBefore == other.pBefore && self.pAfter == other.pAfter
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPVCONTEXT {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPVCONTEXT {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVFEATURE(pub i32);
pub const SPVFEATURE_STRESSED: SPVFEATURE = SPVFEATURE(1i32);
pub const SPVFEATURE_EMPHASIS: SPVFEATURE = SPVFEATURE(2i32);
impl ::core::convert::From<i32> for SPVFEATURE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVFEATURE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVISEMES(pub i32);
pub const SP_VISEME_0: SPVISEMES = SPVISEMES(0i32);
pub const SP_VISEME_1: SPVISEMES = SPVISEMES(1i32);
pub const SP_VISEME_2: SPVISEMES = SPVISEMES(2i32);
pub const SP_VISEME_3: SPVISEMES = SPVISEMES(3i32);
pub const SP_VISEME_4: SPVISEMES = SPVISEMES(4i32);
pub const SP_VISEME_5: SPVISEMES = SPVISEMES(5i32);
pub const SP_VISEME_6: SPVISEMES = SPVISEMES(6i32);
pub const SP_VISEME_7: SPVISEMES = SPVISEMES(7i32);
pub const SP_VISEME_8: SPVISEMES = SPVISEMES(8i32);
pub const SP_VISEME_9: SPVISEMES = SPVISEMES(9i32);
pub const SP_VISEME_10: SPVISEMES = SPVISEMES(10i32);
pub const SP_VISEME_11: SPVISEMES = SPVISEMES(11i32);
pub const SP_VISEME_12: SPVISEMES = SPVISEMES(12i32);
pub const SP_VISEME_13: SPVISEMES = SPVISEMES(13i32);
pub const SP_VISEME_14: SPVISEMES = SPVISEMES(14i32);
pub const SP_VISEME_15: SPVISEMES = SPVISEMES(15i32);
pub const SP_VISEME_16: SPVISEMES = SPVISEMES(16i32);
pub const SP_VISEME_17: SPVISEMES = SPVISEMES(17i32);
pub const SP_VISEME_18: SPVISEMES = SPVISEMES(18i32);
pub const SP_VISEME_19: SPVISEMES = SPVISEMES(19i32);
pub const SP_VISEME_20: SPVISEMES = SPVISEMES(20i32);
pub const SP_VISEME_21: SPVISEMES = SPVISEMES(21i32);
impl ::core::convert::From<i32> for SPVISEMES {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVISEMES {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVLIMITS(pub i32);
pub const SPMIN_VOLUME: SPVLIMITS = SPVLIMITS(0i32);
pub const SPMAX_VOLUME: SPVLIMITS = SPVLIMITS(100i32);
pub const SPMIN_RATE: SPVLIMITS = SPVLIMITS(-10i32);
pub const SPMAX_RATE: SPVLIMITS = SPVLIMITS(10i32);
impl ::core::convert::From<i32> for SPVLIMITS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVLIMITS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPVOICESTATUS {
pub ulCurrentStream: u32,
pub ulLastStreamQueued: u32,
pub hrLastResult: ::windows::core::HRESULT,
pub dwRunningState: u32,
pub ulInputWordPos: u32,
pub ulInputWordLen: u32,
pub ulInputSentPos: u32,
pub ulInputSentLen: u32,
pub lBookmarkId: i32,
pub PhonemeId: u16,
pub VisemeId: SPVISEMES,
pub dwReserved1: u32,
pub dwReserved2: u32,
}
impl SPVOICESTATUS {}
impl ::core::default::Default for SPVOICESTATUS {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPVOICESTATUS {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPVOICESTATUS")
.field("ulCurrentStream", &self.ulCurrentStream)
.field("ulLastStreamQueued", &self.ulLastStreamQueued)
.field("hrLastResult", &self.hrLastResult)
.field("dwRunningState", &self.dwRunningState)
.field("ulInputWordPos", &self.ulInputWordPos)
.field("ulInputWordLen", &self.ulInputWordLen)
.field("ulInputSentPos", &self.ulInputSentPos)
.field("ulInputSentLen", &self.ulInputSentLen)
.field("lBookmarkId", &self.lBookmarkId)
.field("PhonemeId", &self.PhonemeId)
.field("VisemeId", &self.VisemeId)
.field("dwReserved1", &self.dwReserved1)
.field("dwReserved2", &self.dwReserved2)
.finish()
}
}
impl ::core::cmp::PartialEq for SPVOICESTATUS {
fn eq(&self, other: &Self) -> bool {
self.ulCurrentStream == other.ulCurrentStream
&& self.ulLastStreamQueued == other.ulLastStreamQueued
&& self.hrLastResult == other.hrLastResult
&& self.dwRunningState == other.dwRunningState
&& self.ulInputWordPos == other.ulInputWordPos
&& self.ulInputWordLen == other.ulInputWordLen
&& self.ulInputSentPos == other.ulInputSentPos
&& self.ulInputSentLen == other.ulInputSentLen
&& self.lBookmarkId == other.lBookmarkId
&& self.PhonemeId == other.PhonemeId
&& self.VisemeId == other.VisemeId
&& self.dwReserved1 == other.dwReserved1
&& self.dwReserved2 == other.dwReserved2
}
}
impl ::core::cmp::Eq for SPVOICESTATUS {}
unsafe impl ::windows::core::Abi for SPVOICESTATUS {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPVPITCH {
pub MiddleAdj: i32,
pub RangeAdj: i32,
}
impl SPVPITCH {}
impl ::core::default::Default for SPVPITCH {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPVPITCH {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPVPITCH").field("MiddleAdj", &self.MiddleAdj).field("RangeAdj", &self.RangeAdj).finish()
}
}
impl ::core::cmp::PartialEq for SPVPITCH {
fn eq(&self, other: &Self) -> bool {
self.MiddleAdj == other.MiddleAdj && self.RangeAdj == other.RangeAdj
}
}
impl ::core::cmp::Eq for SPVPITCH {}
unsafe impl ::windows::core::Abi for SPVPITCH {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPVPRIORITY(pub i32);
pub const SPVPRI_NORMAL: SPVPRIORITY = SPVPRIORITY(0i32);
pub const SPVPRI_ALERT: SPVPRIORITY = SPVPRIORITY(1i32);
pub const SPVPRI_OVER: SPVPRIORITY = SPVPRIORITY(2i32);
impl ::core::convert::From<i32> for SPVPRIORITY {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPVPRIORITY {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPVSTATE {
pub eAction: SPVACTIONS,
pub LangID: u16,
pub wReserved: u16,
pub EmphAdj: i32,
pub RateAdj: i32,
pub Volume: u32,
pub PitchAdj: SPVPITCH,
pub SilenceMSecs: u32,
pub pPhoneIds: *mut u16,
pub ePartOfSpeech: SPPARTOFSPEECH,
pub Context: SPVCONTEXT,
}
#[cfg(feature = "Win32_Foundation")]
impl SPVSTATE {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPVSTATE {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPVSTATE {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPVSTATE")
.field("eAction", &self.eAction)
.field("LangID", &self.LangID)
.field("wReserved", &self.wReserved)
.field("EmphAdj", &self.EmphAdj)
.field("RateAdj", &self.RateAdj)
.field("Volume", &self.Volume)
.field("PitchAdj", &self.PitchAdj)
.field("SilenceMSecs", &self.SilenceMSecs)
.field("pPhoneIds", &self.pPhoneIds)
.field("ePartOfSpeech", &self.ePartOfSpeech)
.field("Context", &self.Context)
.finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPVSTATE {
fn eq(&self, other: &Self) -> bool {
self.eAction == other.eAction && self.LangID == other.LangID && self.wReserved == other.wReserved && self.EmphAdj == other.EmphAdj && self.RateAdj == other.RateAdj && self.Volume == other.Volume && self.PitchAdj == other.PitchAdj && self.SilenceMSecs == other.SilenceMSecs && self.pPhoneIds == other.pPhoneIds && self.ePartOfSpeech == other.ePartOfSpeech && self.Context == other.Context
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPVSTATE {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPVSTATE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPWAVEFORMATTYPE(pub i32);
pub const SPWF_INPUT: SPWAVEFORMATTYPE = SPWAVEFORMATTYPE(0i32);
pub const SPWF_SRENGINE: SPWAVEFORMATTYPE = SPWAVEFORMATTYPE(1i32);
impl ::core::convert::From<i32> for SPWAVEFORMATTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPWAVEFORMATTYPE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPWORD {
pub pNextWord: *mut SPWORD,
pub LangID: u16,
pub wReserved: u16,
pub eWordType: SPWORDTYPE,
pub pszWord: super::super::Foundation::PWSTR,
pub pFirstWordPronunciation: *mut SPWORDPRONUNCIATION,
}
#[cfg(feature = "Win32_Foundation")]
impl SPWORD {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPWORD {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPWORD {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPWORD").field("pNextWord", &self.pNextWord).field("LangID", &self.LangID).field("wReserved", &self.wReserved).field("eWordType", &self.eWordType).field("pszWord", &self.pszWord).field("pFirstWordPronunciation", &self.pFirstWordPronunciation).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPWORD {
fn eq(&self, other: &Self) -> bool {
self.pNextWord == other.pNextWord && self.LangID == other.LangID && self.wReserved == other.wReserved && self.eWordType == other.eWordType && self.pszWord == other.pszWord && self.pFirstWordPronunciation == other.pFirstWordPronunciation
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPWORD {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPWORD {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
#[cfg(feature = "Win32_Foundation")]
pub struct SPWORDLIST {
pub ulSize: u32,
pub pvBuffer: *mut u8,
pub pFirstWord: *mut SPWORD,
}
#[cfg(feature = "Win32_Foundation")]
impl SPWORDLIST {}
#[cfg(feature = "Win32_Foundation")]
impl ::core::default::Default for SPWORDLIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::fmt::Debug for SPWORDLIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPWORDLIST").field("ulSize", &self.ulSize).field("pvBuffer", &self.pvBuffer).field("pFirstWord", &self.pFirstWord).finish()
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::PartialEq for SPWORDLIST {
fn eq(&self, other: &Self) -> bool {
self.ulSize == other.ulSize && self.pvBuffer == other.pvBuffer && self.pFirstWord == other.pFirstWord
}
}
#[cfg(feature = "Win32_Foundation")]
impl ::core::cmp::Eq for SPWORDLIST {}
#[cfg(feature = "Win32_Foundation")]
unsafe impl ::windows::core::Abi for SPWORDLIST {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPWORDPRONOUNCEABLE(pub i32);
pub const SPWP_UNKNOWN_WORD_UNPRONOUNCEABLE: SPWORDPRONOUNCEABLE = SPWORDPRONOUNCEABLE(0i32);
pub const SPWP_UNKNOWN_WORD_PRONOUNCEABLE: SPWORDPRONOUNCEABLE = SPWORDPRONOUNCEABLE(1i32);
pub const SPWP_KNOWN_WORD_PRONOUNCEABLE: SPWORDPRONOUNCEABLE = SPWORDPRONOUNCEABLE(2i32);
impl ::core::convert::From<i32> for SPWORDPRONOUNCEABLE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPWORDPRONOUNCEABLE {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPWORDPRONUNCIATION {
pub pNextWordPronunciation: *mut SPWORDPRONUNCIATION,
pub eLexiconType: SPLEXICONTYPE,
pub LangID: u16,
pub wPronunciationFlags: u16,
pub ePartOfSpeech: SPPARTOFSPEECH,
pub szPronunciation: [u16; 1],
}
impl SPWORDPRONUNCIATION {}
impl ::core::default::Default for SPWORDPRONUNCIATION {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPWORDPRONUNCIATION {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPWORDPRONUNCIATION")
.field("pNextWordPronunciation", &self.pNextWordPronunciation)
.field("eLexiconType", &self.eLexiconType)
.field("LangID", &self.LangID)
.field("wPronunciationFlags", &self.wPronunciationFlags)
.field("ePartOfSpeech", &self.ePartOfSpeech)
.field("szPronunciation", &self.szPronunciation)
.finish()
}
}
impl ::core::cmp::PartialEq for SPWORDPRONUNCIATION {
fn eq(&self, other: &Self) -> bool {
self.pNextWordPronunciation == other.pNextWordPronunciation && self.eLexiconType == other.eLexiconType && self.LangID == other.LangID && self.wPronunciationFlags == other.wPronunciationFlags && self.ePartOfSpeech == other.ePartOfSpeech && self.szPronunciation == other.szPronunciation
}
}
impl ::core::cmp::Eq for SPWORDPRONUNCIATION {}
unsafe impl ::windows::core::Abi for SPWORDPRONUNCIATION {
type Abi = Self;
}
#[derive(:: core :: clone :: Clone, :: core :: marker :: Copy)]
#[repr(C)]
pub struct SPWORDPRONUNCIATIONLIST {
pub ulSize: u32,
pub pvBuffer: *mut u8,
pub pFirstWordPronunciation: *mut SPWORDPRONUNCIATION,
}
impl SPWORDPRONUNCIATIONLIST {}
impl ::core::default::Default for SPWORDPRONUNCIATIONLIST {
fn default() -> Self {
unsafe { ::core::mem::zeroed() }
}
}
impl ::core::fmt::Debug for SPWORDPRONUNCIATIONLIST {
fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
fmt.debug_struct("SPWORDPRONUNCIATIONLIST").field("ulSize", &self.ulSize).field("pvBuffer", &self.pvBuffer).field("pFirstWordPronunciation", &self.pFirstWordPronunciation).finish()
}
}
impl ::core::cmp::PartialEq for SPWORDPRONUNCIATIONLIST {
fn eq(&self, other: &Self) -> bool {
self.ulSize == other.ulSize && self.pvBuffer == other.pvBuffer && self.pFirstWordPronunciation == other.pFirstWordPronunciation
}
}
impl ::core::cmp::Eq for SPWORDPRONUNCIATIONLIST {}
unsafe impl ::windows::core::Abi for SPWORDPRONUNCIATIONLIST {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPWORDTYPE(pub i32);
pub const eWORDTYPE_ADDED: SPWORDTYPE = SPWORDTYPE(1i32);
pub const eWORDTYPE_DELETED: SPWORDTYPE = SPWORDTYPE(2i32);
impl ::core::convert::From<i32> for SPWORDTYPE {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPWORDTYPE {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SPXMLRESULTOPTIONS(pub i32);
pub const SPXRO_SML: SPXMLRESULTOPTIONS = SPXMLRESULTOPTIONS(0i32);
pub const SPXRO_Alternates_SML: SPXMLRESULTOPTIONS = SPXMLRESULTOPTIONS(1i32);
impl ::core::convert::From<i32> for SPXMLRESULTOPTIONS {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SPXMLRESULTOPTIONS {
type Abi = Self;
}
pub const SP_EMULATE_RESULT: u32 = 1073741824u32;
pub const SP_LOW_CONFIDENCE: i32 = -1i32;
pub const SP_MAX_LANGIDS: u32 = 20u32;
pub const SP_MAX_PRON_LENGTH: u32 = 384u32;
pub const SP_MAX_WORD_LENGTH: u32 = 128u32;
pub const SP_NORMAL_CONFIDENCE: u32 = 0u32;
pub const SP_STREAMPOS_ASAP: u32 = 0u32;
pub const SP_STREAMPOS_REALTIME: i32 = -1i32;
pub const SpAudioFormat: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9ef96870_e160_4792_820d_48cf0649e4ec);
pub const SpCompressedLexicon: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x90903716_2f42_11d3_9c26_00c04f8ef87c);
pub const SpCustomStream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x8dbef13f_1948_4aa8_8cf0_048eebed95d8);
pub const SpFileStream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x947812b3_2ae1_4644_ba86_9e90ded7ec91);
pub const SpInProcRecoContext: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x73ad6842_ace0_45e8_a4dd_8795881a2c2a);
pub const SpInprocRecognizer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x41b89b6b_9399_11d2_9623_00c04f8ee628);
pub const SpLexicon: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0655e396_25d0_11d3_9c26_00c04f8ef87c);
pub const SpMMAudioEnum: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xab1890a0_e91f_11d2_bb91_00c04f8ee6c0);
pub const SpMMAudioIn: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xcf3d2e50_53f2_11d2_960c_00c04f8ee628);
pub const SpMMAudioOut: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa8c680eb_3d32_11d2_9ee7_00c04f797396);
pub const SpMemoryStream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x5fb7ef7d_dff4_468a_b6b7_2fcbd188f994);
pub const SpNotifyTranslator: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xe2ae5372_5d40_11d2_960e_00c04f8ee628);
pub const SpNullPhoneConverter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x455f24e9_7396_4a16_9715_7c0fdbe3efe3);
pub const SpObjectToken: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xef411752_3736_4cb4_9c8c_8ef4ccb58efe);
pub const SpObjectTokenCategory: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa910187f_0c7a_45ac_92cc_59edafb77b53);
pub const SpPhoneConverter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x9185f743_1143_4c28_86b5_bff14f20e5c8);
pub const SpPhoneticAlphabetConverter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x4f414126_dfe3_4629_99ee_797978317ead);
pub const SpPhraseInfoBuilder: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc23fc28d_c55f_4720_8b32_91f73c2bd5d1);
pub const SpResourceManager: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96749373_3391_11d2_9ee3_00c04f797396);
pub const SpSharedRecoContext: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x47206204_5eca_11d2_960f_00c04f8ee628);
pub const SpSharedRecognizer: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x3bee4890_4fe9_4a37_8c1e_5e7e12791c1f);
pub const SpShortcut: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0d722f1a_9fcf_4e62_96d8_6df8f01a26aa);
pub const SpStream: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x715d9c59_4442_11d2_9605_00c04f8ee628);
pub const SpStreamFormatConverter: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7013943a_e2ec_11d2_a086_00c04f8ef9b5);
pub const SpTextSelectionInformation: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x0f92030a_cbfd_4ab8_a164_ff5985547ff6);
pub const SpUnCompressedLexicon: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc9e37c15_df92_4727_85d6_72e5eeb6995a);
pub const SpVoice: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x96749377_3391_11d2_9ee3_00c04f797396);
pub const SpWaveFormatEx: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xc79a574c_63be_44b9_801f_283f87f898be);
pub const SpeechAllElements: i32 = -1i32;
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechAudioFormatType(pub i32);
pub const SAFTDefault: SpeechAudioFormatType = SpeechAudioFormatType(-1i32);
pub const SAFTNoAssignedFormat: SpeechAudioFormatType = SpeechAudioFormatType(0i32);
pub const SAFTText: SpeechAudioFormatType = SpeechAudioFormatType(1i32);
pub const SAFTNonStandardFormat: SpeechAudioFormatType = SpeechAudioFormatType(2i32);
pub const SAFTExtendedAudioFormat: SpeechAudioFormatType = SpeechAudioFormatType(3i32);
pub const SAFT8kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(4i32);
pub const SAFT8kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(5i32);
pub const SAFT8kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(6i32);
pub const SAFT8kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(7i32);
pub const SAFT11kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(8i32);
pub const SAFT11kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(9i32);
pub const SAFT11kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(10i32);
pub const SAFT11kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(11i32);
pub const SAFT12kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(12i32);
pub const SAFT12kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(13i32);
pub const SAFT12kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(14i32);
pub const SAFT12kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(15i32);
pub const SAFT16kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(16i32);
pub const SAFT16kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(17i32);
pub const SAFT16kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(18i32);
pub const SAFT16kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(19i32);
pub const SAFT22kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(20i32);
pub const SAFT22kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(21i32);
pub const SAFT22kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(22i32);
pub const SAFT22kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(23i32);
pub const SAFT24kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(24i32);
pub const SAFT24kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(25i32);
pub const SAFT24kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(26i32);
pub const SAFT24kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(27i32);
pub const SAFT32kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(28i32);
pub const SAFT32kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(29i32);
pub const SAFT32kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(30i32);
pub const SAFT32kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(31i32);
pub const SAFT44kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(32i32);
pub const SAFT44kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(33i32);
pub const SAFT44kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(34i32);
pub const SAFT44kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(35i32);
pub const SAFT48kHz8BitMono: SpeechAudioFormatType = SpeechAudioFormatType(36i32);
pub const SAFT48kHz8BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(37i32);
pub const SAFT48kHz16BitMono: SpeechAudioFormatType = SpeechAudioFormatType(38i32);
pub const SAFT48kHz16BitStereo: SpeechAudioFormatType = SpeechAudioFormatType(39i32);
pub const SAFTTrueSpeech_8kHz1BitMono: SpeechAudioFormatType = SpeechAudioFormatType(40i32);
pub const SAFTCCITT_ALaw_8kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(41i32);
pub const SAFTCCITT_ALaw_8kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(42i32);
pub const SAFTCCITT_ALaw_11kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(43i32);
pub const SAFTCCITT_ALaw_11kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(44i32);
pub const SAFTCCITT_ALaw_22kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(45i32);
pub const SAFTCCITT_ALaw_22kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(46i32);
pub const SAFTCCITT_ALaw_44kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(47i32);
pub const SAFTCCITT_ALaw_44kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(48i32);
pub const SAFTCCITT_uLaw_8kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(49i32);
pub const SAFTCCITT_uLaw_8kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(50i32);
pub const SAFTCCITT_uLaw_11kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(51i32);
pub const SAFTCCITT_uLaw_11kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(52i32);
pub const SAFTCCITT_uLaw_22kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(53i32);
pub const SAFTCCITT_uLaw_22kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(54i32);
pub const SAFTCCITT_uLaw_44kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(55i32);
pub const SAFTCCITT_uLaw_44kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(56i32);
pub const SAFTADPCM_8kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(57i32);
pub const SAFTADPCM_8kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(58i32);
pub const SAFTADPCM_11kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(59i32);
pub const SAFTADPCM_11kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(60i32);
pub const SAFTADPCM_22kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(61i32);
pub const SAFTADPCM_22kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(62i32);
pub const SAFTADPCM_44kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(63i32);
pub const SAFTADPCM_44kHzStereo: SpeechAudioFormatType = SpeechAudioFormatType(64i32);
pub const SAFTGSM610_8kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(65i32);
pub const SAFTGSM610_11kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(66i32);
pub const SAFTGSM610_22kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(67i32);
pub const SAFTGSM610_44kHzMono: SpeechAudioFormatType = SpeechAudioFormatType(68i32);
impl ::core::convert::From<i32> for SpeechAudioFormatType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechAudioFormatType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechAudioState(pub i32);
pub const SASClosed: SpeechAudioState = SpeechAudioState(0i32);
pub const SASStop: SpeechAudioState = SpeechAudioState(1i32);
pub const SASPause: SpeechAudioState = SpeechAudioState(2i32);
pub const SASRun: SpeechAudioState = SpeechAudioState(3i32);
impl ::core::convert::From<i32> for SpeechAudioState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechAudioState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechBookmarkOptions(pub i32);
pub const SBONone: SpeechBookmarkOptions = SpeechBookmarkOptions(0i32);
pub const SBOPause: SpeechBookmarkOptions = SpeechBookmarkOptions(1i32);
impl ::core::convert::From<i32> for SpeechBookmarkOptions {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechBookmarkOptions {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechDataKeyLocation(pub i32);
pub const SDKLDefaultLocation: SpeechDataKeyLocation = SpeechDataKeyLocation(0i32);
pub const SDKLCurrentUser: SpeechDataKeyLocation = SpeechDataKeyLocation(1i32);
pub const SDKLLocalMachine: SpeechDataKeyLocation = SpeechDataKeyLocation(2i32);
pub const SDKLCurrentConfig: SpeechDataKeyLocation = SpeechDataKeyLocation(5i32);
impl ::core::convert::From<i32> for SpeechDataKeyLocation {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechDataKeyLocation {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechDiscardType(pub i32);
pub const SDTProperty: SpeechDiscardType = SpeechDiscardType(1i32);
pub const SDTReplacement: SpeechDiscardType = SpeechDiscardType(2i32);
pub const SDTRule: SpeechDiscardType = SpeechDiscardType(4i32);
pub const SDTDisplayText: SpeechDiscardType = SpeechDiscardType(8i32);
pub const SDTLexicalForm: SpeechDiscardType = SpeechDiscardType(16i32);
pub const SDTPronunciation: SpeechDiscardType = SpeechDiscardType(32i32);
pub const SDTAudio: SpeechDiscardType = SpeechDiscardType(64i32);
pub const SDTAlternates: SpeechDiscardType = SpeechDiscardType(128i32);
pub const SDTAll: SpeechDiscardType = SpeechDiscardType(255i32);
impl ::core::convert::From<i32> for SpeechDiscardType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechDiscardType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechDisplayAttributes(pub i32);
pub const SDA_No_Trailing_Space: SpeechDisplayAttributes = SpeechDisplayAttributes(0i32);
pub const SDA_One_Trailing_Space: SpeechDisplayAttributes = SpeechDisplayAttributes(2i32);
pub const SDA_Two_Trailing_Spaces: SpeechDisplayAttributes = SpeechDisplayAttributes(4i32);
pub const SDA_Consume_Leading_Spaces: SpeechDisplayAttributes = SpeechDisplayAttributes(8i32);
impl ::core::convert::From<i32> for SpeechDisplayAttributes {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechDisplayAttributes {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechEmulationCompareFlags(pub i32);
pub const SECFIgnoreCase: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(1i32);
pub const SECFIgnoreKanaType: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(65536i32);
pub const SECFIgnoreWidth: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(131072i32);
pub const SECFNoSpecialChars: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(536870912i32);
pub const SECFEmulateResult: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(1073741824i32);
pub const SECFDefault: SpeechEmulationCompareFlags = SpeechEmulationCompareFlags(196609i32);
impl ::core::convert::From<i32> for SpeechEmulationCompareFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechEmulationCompareFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechEngineConfidence(pub i32);
pub const SECLowConfidence: SpeechEngineConfidence = SpeechEngineConfidence(-1i32);
pub const SECNormalConfidence: SpeechEngineConfidence = SpeechEngineConfidence(0i32);
pub const SECHighConfidence: SpeechEngineConfidence = SpeechEngineConfidence(1i32);
impl ::core::convert::From<i32> for SpeechEngineConfidence {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechEngineConfidence {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechFormatType(pub i32);
pub const SFTInput: SpeechFormatType = SpeechFormatType(0i32);
pub const SFTSREngine: SpeechFormatType = SpeechFormatType(1i32);
impl ::core::convert::From<i32> for SpeechFormatType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechFormatType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechGrammarRuleStateTransitionType(pub i32);
pub const SGRSTTEpsilon: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(0i32);
pub const SGRSTTWord: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(1i32);
pub const SGRSTTRule: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(2i32);
pub const SGRSTTDictation: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(3i32);
pub const SGRSTTWildcard: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(4i32);
pub const SGRSTTTextBuffer: SpeechGrammarRuleStateTransitionType = SpeechGrammarRuleStateTransitionType(5i32);
impl ::core::convert::From<i32> for SpeechGrammarRuleStateTransitionType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechGrammarRuleStateTransitionType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechGrammarState(pub i32);
pub const SGSEnabled: SpeechGrammarState = SpeechGrammarState(1i32);
pub const SGSDisabled: SpeechGrammarState = SpeechGrammarState(0i32);
pub const SGSExclusive: SpeechGrammarState = SpeechGrammarState(3i32);
impl ::core::convert::From<i32> for SpeechGrammarState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechGrammarState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechGrammarWordType(pub i32);
pub const SGDisplay: SpeechGrammarWordType = SpeechGrammarWordType(0i32);
pub const SGLexical: SpeechGrammarWordType = SpeechGrammarWordType(1i32);
pub const SGPronounciation: SpeechGrammarWordType = SpeechGrammarWordType(2i32);
pub const SGLexicalNoSpecialChars: SpeechGrammarWordType = SpeechGrammarWordType(3i32);
impl ::core::convert::From<i32> for SpeechGrammarWordType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechGrammarWordType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechInterference(pub i32);
pub const SINone: SpeechInterference = SpeechInterference(0i32);
pub const SINoise: SpeechInterference = SpeechInterference(1i32);
pub const SINoSignal: SpeechInterference = SpeechInterference(2i32);
pub const SITooLoud: SpeechInterference = SpeechInterference(3i32);
pub const SITooQuiet: SpeechInterference = SpeechInterference(4i32);
pub const SITooFast: SpeechInterference = SpeechInterference(5i32);
pub const SITooSlow: SpeechInterference = SpeechInterference(6i32);
impl ::core::convert::From<i32> for SpeechInterference {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechInterference {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechLexiconType(pub i32);
pub const SLTUser: SpeechLexiconType = SpeechLexiconType(1i32);
pub const SLTApp: SpeechLexiconType = SpeechLexiconType(2i32);
impl ::core::convert::From<i32> for SpeechLexiconType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechLexiconType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechLoadOption(pub i32);
pub const SLOStatic: SpeechLoadOption = SpeechLoadOption(0i32);
pub const SLODynamic: SpeechLoadOption = SpeechLoadOption(1i32);
impl ::core::convert::From<i32> for SpeechLoadOption {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechLoadOption {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechPartOfSpeech(pub i32);
pub const SPSNotOverriden: SpeechPartOfSpeech = SpeechPartOfSpeech(-1i32);
pub const SPSUnknown: SpeechPartOfSpeech = SpeechPartOfSpeech(0i32);
pub const SPSNoun: SpeechPartOfSpeech = SpeechPartOfSpeech(4096i32);
pub const SPSVerb: SpeechPartOfSpeech = SpeechPartOfSpeech(8192i32);
pub const SPSModifier: SpeechPartOfSpeech = SpeechPartOfSpeech(12288i32);
pub const SPSFunction: SpeechPartOfSpeech = SpeechPartOfSpeech(16384i32);
pub const SPSInterjection: SpeechPartOfSpeech = SpeechPartOfSpeech(20480i32);
pub const SPSLMA: SpeechPartOfSpeech = SpeechPartOfSpeech(28672i32);
pub const SPSSuppressWord: SpeechPartOfSpeech = SpeechPartOfSpeech(61440i32);
impl ::core::convert::From<i32> for SpeechPartOfSpeech {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechPartOfSpeech {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRecoContextState(pub i32);
pub const SRCS_Disabled: SpeechRecoContextState = SpeechRecoContextState(0i32);
pub const SRCS_Enabled: SpeechRecoContextState = SpeechRecoContextState(1i32);
impl ::core::convert::From<i32> for SpeechRecoContextState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRecoContextState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRecoEvents(pub i32);
pub const SREStreamEnd: SpeechRecoEvents = SpeechRecoEvents(1i32);
pub const SRESoundStart: SpeechRecoEvents = SpeechRecoEvents(2i32);
pub const SRESoundEnd: SpeechRecoEvents = SpeechRecoEvents(4i32);
pub const SREPhraseStart: SpeechRecoEvents = SpeechRecoEvents(8i32);
pub const SRERecognition: SpeechRecoEvents = SpeechRecoEvents(16i32);
pub const SREHypothesis: SpeechRecoEvents = SpeechRecoEvents(32i32);
pub const SREBookmark: SpeechRecoEvents = SpeechRecoEvents(64i32);
pub const SREPropertyNumChange: SpeechRecoEvents = SpeechRecoEvents(128i32);
pub const SREPropertyStringChange: SpeechRecoEvents = SpeechRecoEvents(256i32);
pub const SREFalseRecognition: SpeechRecoEvents = SpeechRecoEvents(512i32);
pub const SREInterference: SpeechRecoEvents = SpeechRecoEvents(1024i32);
pub const SRERequestUI: SpeechRecoEvents = SpeechRecoEvents(2048i32);
pub const SREStateChange: SpeechRecoEvents = SpeechRecoEvents(4096i32);
pub const SREAdaptation: SpeechRecoEvents = SpeechRecoEvents(8192i32);
pub const SREStreamStart: SpeechRecoEvents = SpeechRecoEvents(16384i32);
pub const SRERecoOtherContext: SpeechRecoEvents = SpeechRecoEvents(32768i32);
pub const SREAudioLevel: SpeechRecoEvents = SpeechRecoEvents(65536i32);
pub const SREPrivate: SpeechRecoEvents = SpeechRecoEvents(262144i32);
pub const SREAllEvents: SpeechRecoEvents = SpeechRecoEvents(393215i32);
impl ::core::convert::From<i32> for SpeechRecoEvents {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRecoEvents {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRecognitionType(pub i32);
pub const SRTStandard: SpeechRecognitionType = SpeechRecognitionType(0i32);
pub const SRTAutopause: SpeechRecognitionType = SpeechRecognitionType(1i32);
pub const SRTEmulated: SpeechRecognitionType = SpeechRecognitionType(2i32);
pub const SRTSMLTimeout: SpeechRecognitionType = SpeechRecognitionType(4i32);
pub const SRTExtendableParse: SpeechRecognitionType = SpeechRecognitionType(8i32);
pub const SRTReSent: SpeechRecognitionType = SpeechRecognitionType(16i32);
impl ::core::convert::From<i32> for SpeechRecognitionType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRecognitionType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRecognizerState(pub i32);
pub const SRSInactive: SpeechRecognizerState = SpeechRecognizerState(0i32);
pub const SRSActive: SpeechRecognizerState = SpeechRecognizerState(1i32);
pub const SRSActiveAlways: SpeechRecognizerState = SpeechRecognizerState(2i32);
pub const SRSInactiveWithPurge: SpeechRecognizerState = SpeechRecognizerState(3i32);
impl ::core::convert::From<i32> for SpeechRecognizerState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRecognizerState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRetainedAudioOptions(pub i32);
pub const SRAONone: SpeechRetainedAudioOptions = SpeechRetainedAudioOptions(0i32);
pub const SRAORetainAudio: SpeechRetainedAudioOptions = SpeechRetainedAudioOptions(1i32);
impl ::core::convert::From<i32> for SpeechRetainedAudioOptions {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRetainedAudioOptions {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRuleAttributes(pub i32);
pub const SRATopLevel: SpeechRuleAttributes = SpeechRuleAttributes(1i32);
pub const SRADefaultToActive: SpeechRuleAttributes = SpeechRuleAttributes(2i32);
pub const SRAExport: SpeechRuleAttributes = SpeechRuleAttributes(4i32);
pub const SRAImport: SpeechRuleAttributes = SpeechRuleAttributes(8i32);
pub const SRAInterpreter: SpeechRuleAttributes = SpeechRuleAttributes(16i32);
pub const SRADynamic: SpeechRuleAttributes = SpeechRuleAttributes(32i32);
pub const SRARoot: SpeechRuleAttributes = SpeechRuleAttributes(64i32);
impl ::core::convert::From<i32> for SpeechRuleAttributes {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRuleAttributes {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRuleState(pub i32);
pub const SGDSInactive: SpeechRuleState = SpeechRuleState(0i32);
pub const SGDSActive: SpeechRuleState = SpeechRuleState(1i32);
pub const SGDSActiveWithAutoPause: SpeechRuleState = SpeechRuleState(3i32);
pub const SGDSActiveUserDelimited: SpeechRuleState = SpeechRuleState(4i32);
impl ::core::convert::From<i32> for SpeechRuleState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRuleState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechRunState(pub i32);
pub const SRSEDone: SpeechRunState = SpeechRunState(1i32);
pub const SRSEIsSpeaking: SpeechRunState = SpeechRunState(2i32);
impl ::core::convert::From<i32> for SpeechRunState {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechRunState {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechSpecialTransitionType(pub i32);
pub const SSTTWildcard: SpeechSpecialTransitionType = SpeechSpecialTransitionType(1i32);
pub const SSTTDictation: SpeechSpecialTransitionType = SpeechSpecialTransitionType(2i32);
pub const SSTTTextBuffer: SpeechSpecialTransitionType = SpeechSpecialTransitionType(3i32);
impl ::core::convert::From<i32> for SpeechSpecialTransitionType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechSpecialTransitionType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechStreamFileMode(pub i32);
pub const SSFMOpenForRead: SpeechStreamFileMode = SpeechStreamFileMode(0i32);
pub const SSFMOpenReadWrite: SpeechStreamFileMode = SpeechStreamFileMode(1i32);
pub const SSFMCreate: SpeechStreamFileMode = SpeechStreamFileMode(2i32);
pub const SSFMCreateForWrite: SpeechStreamFileMode = SpeechStreamFileMode(3i32);
impl ::core::convert::From<i32> for SpeechStreamFileMode {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechStreamFileMode {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechStreamSeekPositionType(pub u32);
pub const SSSPTRelativeToStart: SpeechStreamSeekPositionType = SpeechStreamSeekPositionType(0u32);
pub const SSSPTRelativeToCurrentPosition: SpeechStreamSeekPositionType = SpeechStreamSeekPositionType(1u32);
pub const SSSPTRelativeToEnd: SpeechStreamSeekPositionType = SpeechStreamSeekPositionType(2u32);
impl ::core::convert::From<u32> for SpeechStreamSeekPositionType {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechStreamSeekPositionType {
type Abi = Self;
}
impl ::core::ops::BitOr for SpeechStreamSeekPositionType {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SpeechStreamSeekPositionType {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SpeechStreamSeekPositionType {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SpeechStreamSeekPositionType {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SpeechStreamSeekPositionType {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechTokenContext(pub u32);
pub const STCInprocServer: SpeechTokenContext = SpeechTokenContext(1u32);
pub const STCInprocHandler: SpeechTokenContext = SpeechTokenContext(2u32);
pub const STCLocalServer: SpeechTokenContext = SpeechTokenContext(4u32);
pub const STCRemoteServer: SpeechTokenContext = SpeechTokenContext(16u32);
pub const STCAll: SpeechTokenContext = SpeechTokenContext(23u32);
impl ::core::convert::From<u32> for SpeechTokenContext {
fn from(value: u32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechTokenContext {
type Abi = Self;
}
impl ::core::ops::BitOr for SpeechTokenContext {
type Output = Self;
fn bitor(self, rhs: Self) -> Self {
Self(self.0 | rhs.0)
}
}
impl ::core::ops::BitAnd for SpeechTokenContext {
type Output = Self;
fn bitand(self, rhs: Self) -> Self {
Self(self.0 & rhs.0)
}
}
impl ::core::ops::BitOrAssign for SpeechTokenContext {
fn bitor_assign(&mut self, rhs: Self) {
self.0.bitor_assign(rhs.0)
}
}
impl ::core::ops::BitAndAssign for SpeechTokenContext {
fn bitand_assign(&mut self, rhs: Self) {
self.0.bitand_assign(rhs.0)
}
}
impl ::core::ops::Not for SpeechTokenContext {
type Output = Self;
fn not(self) -> Self {
Self(self.0.not())
}
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechTokenShellFolder(pub i32);
pub const STSF_AppData: SpeechTokenShellFolder = SpeechTokenShellFolder(26i32);
pub const STSF_LocalAppData: SpeechTokenShellFolder = SpeechTokenShellFolder(28i32);
pub const STSF_CommonAppData: SpeechTokenShellFolder = SpeechTokenShellFolder(35i32);
pub const STSF_FlagCreate: SpeechTokenShellFolder = SpeechTokenShellFolder(32768i32);
impl ::core::convert::From<i32> for SpeechTokenShellFolder {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechTokenShellFolder {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechVisemeFeature(pub i32);
pub const SVF_None: SpeechVisemeFeature = SpeechVisemeFeature(0i32);
pub const SVF_Stressed: SpeechVisemeFeature = SpeechVisemeFeature(1i32);
pub const SVF_Emphasis: SpeechVisemeFeature = SpeechVisemeFeature(2i32);
impl ::core::convert::From<i32> for SpeechVisemeFeature {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechVisemeFeature {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechVisemeType(pub i32);
pub const SVP_0: SpeechVisemeType = SpeechVisemeType(0i32);
pub const SVP_1: SpeechVisemeType = SpeechVisemeType(1i32);
pub const SVP_2: SpeechVisemeType = SpeechVisemeType(2i32);
pub const SVP_3: SpeechVisemeType = SpeechVisemeType(3i32);
pub const SVP_4: SpeechVisemeType = SpeechVisemeType(4i32);
pub const SVP_5: SpeechVisemeType = SpeechVisemeType(5i32);
pub const SVP_6: SpeechVisemeType = SpeechVisemeType(6i32);
pub const SVP_7: SpeechVisemeType = SpeechVisemeType(7i32);
pub const SVP_8: SpeechVisemeType = SpeechVisemeType(8i32);
pub const SVP_9: SpeechVisemeType = SpeechVisemeType(9i32);
pub const SVP_10: SpeechVisemeType = SpeechVisemeType(10i32);
pub const SVP_11: SpeechVisemeType = SpeechVisemeType(11i32);
pub const SVP_12: SpeechVisemeType = SpeechVisemeType(12i32);
pub const SVP_13: SpeechVisemeType = SpeechVisemeType(13i32);
pub const SVP_14: SpeechVisemeType = SpeechVisemeType(14i32);
pub const SVP_15: SpeechVisemeType = SpeechVisemeType(15i32);
pub const SVP_16: SpeechVisemeType = SpeechVisemeType(16i32);
pub const SVP_17: SpeechVisemeType = SpeechVisemeType(17i32);
pub const SVP_18: SpeechVisemeType = SpeechVisemeType(18i32);
pub const SVP_19: SpeechVisemeType = SpeechVisemeType(19i32);
pub const SVP_20: SpeechVisemeType = SpeechVisemeType(20i32);
pub const SVP_21: SpeechVisemeType = SpeechVisemeType(21i32);
impl ::core::convert::From<i32> for SpeechVisemeType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechVisemeType {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechVoiceEvents(pub i32);
pub const SVEStartInputStream: SpeechVoiceEvents = SpeechVoiceEvents(2i32);
pub const SVEEndInputStream: SpeechVoiceEvents = SpeechVoiceEvents(4i32);
pub const SVEVoiceChange: SpeechVoiceEvents = SpeechVoiceEvents(8i32);
pub const SVEBookmark: SpeechVoiceEvents = SpeechVoiceEvents(16i32);
pub const SVEWordBoundary: SpeechVoiceEvents = SpeechVoiceEvents(32i32);
pub const SVEPhoneme: SpeechVoiceEvents = SpeechVoiceEvents(64i32);
pub const SVESentenceBoundary: SpeechVoiceEvents = SpeechVoiceEvents(128i32);
pub const SVEViseme: SpeechVoiceEvents = SpeechVoiceEvents(256i32);
pub const SVEAudioLevel: SpeechVoiceEvents = SpeechVoiceEvents(512i32);
pub const SVEPrivate: SpeechVoiceEvents = SpeechVoiceEvents(32768i32);
pub const SVEAllEvents: SpeechVoiceEvents = SpeechVoiceEvents(33790i32);
impl ::core::convert::From<i32> for SpeechVoiceEvents {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechVoiceEvents {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechVoicePriority(pub i32);
pub const SVPNormal: SpeechVoicePriority = SpeechVoicePriority(0i32);
pub const SVPAlert: SpeechVoicePriority = SpeechVoicePriority(1i32);
pub const SVPOver: SpeechVoicePriority = SpeechVoicePriority(2i32);
impl ::core::convert::From<i32> for SpeechVoicePriority {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechVoicePriority {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechVoiceSpeakFlags(pub i32);
pub const SVSFDefault: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(0i32);
pub const SVSFlagsAsync: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(1i32);
pub const SVSFPurgeBeforeSpeak: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(2i32);
pub const SVSFIsFilename: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(4i32);
pub const SVSFIsXML: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(8i32);
pub const SVSFIsNotXML: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(16i32);
pub const SVSFPersistXML: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(32i32);
pub const SVSFNLPSpeakPunc: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(64i32);
pub const SVSFParseSapi: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(128i32);
pub const SVSFParseSsml: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(256i32);
pub const SVSFParseAutodetect: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(0i32);
pub const SVSFNLPMask: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(64i32);
pub const SVSFParseMask: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(384i32);
pub const SVSFVoiceMask: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(511i32);
pub const SVSFUnusedFlags: SpeechVoiceSpeakFlags = SpeechVoiceSpeakFlags(-512i32);
impl ::core::convert::From<i32> for SpeechVoiceSpeakFlags {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechVoiceSpeakFlags {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechWordPronounceable(pub i32);
pub const SWPUnknownWordUnpronounceable: SpeechWordPronounceable = SpeechWordPronounceable(0i32);
pub const SWPUnknownWordPronounceable: SpeechWordPronounceable = SpeechWordPronounceable(1i32);
pub const SWPKnownWordPronounceable: SpeechWordPronounceable = SpeechWordPronounceable(2i32);
impl ::core::convert::From<i32> for SpeechWordPronounceable {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechWordPronounceable {
type Abi = Self;
}
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: marker :: Copy, :: core :: clone :: Clone, :: core :: default :: Default, :: core :: fmt :: Debug)]
#[repr(transparent)]
pub struct SpeechWordType(pub i32);
pub const SWTAdded: SpeechWordType = SpeechWordType(1i32);
pub const SWTDeleted: SpeechWordType = SpeechWordType(2i32);
impl ::core::convert::From<i32> for SpeechWordType {
fn from(value: i32) -> Self {
Self(value)
}
}
unsafe impl ::windows::core::Abi for SpeechWordType {
type Abi = Self;
}
pub const Speech_Default_Weight: f32 = 1f32;
pub const Speech_Max_Pron_Length: i32 = 384i32;
pub const Speech_Max_Word_Length: i32 = 128i32;
pub const Speech_StreamPos_Asap: i32 = 0i32;
pub const Speech_StreamPos_RealTime: i32 = -1i32;
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct _ISpeechRecoContextEvents(pub ::windows::core::IUnknown);
impl _ISpeechRecoContextEvents {}
unsafe impl ::windows::core::Interface for _ISpeechRecoContextEvents {
type Vtable = _ISpeechRecoContextEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0x7b8fcb42_0e9d_4f00_a048_7b04d6179d3d);
}
impl ::core::convert::From<_ISpeechRecoContextEvents> for ::windows::core::IUnknown {
fn from(value: _ISpeechRecoContextEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&_ISpeechRecoContextEvents> for ::windows::core::IUnknown {
fn from(value: &_ISpeechRecoContextEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for _ISpeechRecoContextEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a _ISpeechRecoContextEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<_ISpeechRecoContextEvents> for super::super::System::Com::IDispatch {
fn from(value: _ISpeechRecoContextEvents) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&_ISpeechRecoContextEvents> for super::super::System::Com::IDispatch {
fn from(value: &_ISpeechRecoContextEvents) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for _ISpeechRecoContextEvents {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &_ISpeechRecoContextEvents {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct _ISpeechRecoContextEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
#[repr(transparent)]
#[derive(:: core :: cmp :: PartialEq, :: core :: cmp :: Eq, :: core :: clone :: Clone, :: core :: fmt :: Debug)]
pub struct _ISpeechVoiceEvents(pub ::windows::core::IUnknown);
impl _ISpeechVoiceEvents {}
unsafe impl ::windows::core::Interface for _ISpeechVoiceEvents {
type Vtable = _ISpeechVoiceEvents_abi;
const IID: ::windows::core::GUID = ::windows::core::GUID::from_u128(0xa372acd1_3bef_4bbd_8ffb_cb3e2b416af8);
}
impl ::core::convert::From<_ISpeechVoiceEvents> for ::windows::core::IUnknown {
fn from(value: _ISpeechVoiceEvents) -> Self {
value.0
}
}
impl ::core::convert::From<&_ISpeechVoiceEvents> for ::windows::core::IUnknown {
fn from(value: &_ISpeechVoiceEvents) -> Self {
value.0.clone()
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for _ISpeechVoiceEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Owned(self.0)
}
}
impl<'a> ::windows::core::IntoParam<'a, ::windows::core::IUnknown> for &'a _ISpeechVoiceEvents {
fn into_param(self) -> ::windows::core::Param<'a, ::windows::core::IUnknown> {
::windows::core::Param::Borrowed(&self.0)
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<_ISpeechVoiceEvents> for super::super::System::Com::IDispatch {
fn from(value: _ISpeechVoiceEvents) -> Self {
unsafe { ::core::mem::transmute(value) }
}
}
#[cfg(feature = "Win32_System_Com")]
impl ::core::convert::From<&_ISpeechVoiceEvents> for super::super::System::Com::IDispatch {
fn from(value: &_ISpeechVoiceEvents) -> Self {
::core::convert::From::from(::core::clone::Clone::clone(value))
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for _ISpeechVoiceEvents {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Owned(unsafe { ::core::mem::transmute(self) })
}
}
#[cfg(feature = "Win32_System_Com")]
impl<'a> ::windows::core::IntoParam<'a, super::super::System::Com::IDispatch> for &_ISpeechVoiceEvents {
fn into_param(self) -> ::windows::core::Param<'a, super::super::System::Com::IDispatch> {
::windows::core::Param::Borrowed(unsafe { ::core::mem::transmute(self) })
}
}
#[repr(C)]
#[doc(hidden)]
pub struct _ISpeechVoiceEvents_abi(
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, iid: &::windows::core::GUID, interface: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr) -> u32,
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, pctinfo: *mut u32) -> ::windows::core::HRESULT,
#[cfg(feature = "Win32_System_Com")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, itinfo: u32, lcid: u32, pptinfo: *mut ::windows::core::RawPtr) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_System_Com"))] usize,
#[cfg(feature = "Win32_Foundation")] pub unsafe extern "system" fn(this: ::windows::core::RawPtr, riid: *const ::windows::core::GUID, rgsznames: *const super::super::Foundation::PWSTR, cnames: u32, lcid: u32, rgdispid: *mut i32) -> ::windows::core::HRESULT,
#[cfg(not(feature = "Win32_Foundation"))] usize,
#[cfg(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole"))]
pub unsafe extern "system" fn(this: ::windows::core::RawPtr, dispidmember: i32, riid: *const ::windows::core::GUID, lcid: u32, wflags: u16, pdispparams: *const super::super::System::Com::DISPPARAMS, pvarresult: *mut ::core::mem::ManuallyDrop<super::super::System::Com::VARIANT>, pexcepinfo: *mut ::core::mem::ManuallyDrop<super::super::System::Com::EXCEPINFO>, puargerr: *mut u32) -> ::windows::core::HRESULT,
#[cfg(not(all(feature = "Win32_Foundation", feature = "Win32_System_Com", feature = "Win32_System_Ole")))] usize,
);
|
use crate::{NewService, Service};
use futures::{Future, IntoFuture, Poll};
pub type BoxedService<Req, Res, Err> = Box<
Service<
Request = Req,
Response = Res,
Error = Err,
Future = Box<Future<Item = Res, Error = Err>>,
>,
>;
/// Create boxed new service
pub fn new_service<T, C>(
service: T,
) -> BoxedNewService<C, T::Request, T::Response, T::Error, T::InitError>
where
C: 'static,
T: NewService<C> + 'static,
T::Request: 'static,
T::Response: 'static,
T::Service: 'static,
T::Future: 'static,
T::Error: 'static,
T::InitError: 'static,
{
BoxedNewService(Box::new(NewServiceWrapper {
service,
_t: std::marker::PhantomData,
}))
}
/// Create boxed service
pub fn service<T>(service: T) -> BoxedService<T::Request, T::Response, T::Error>
where
T: Service + 'static,
T::Future: 'static,
{
Box::new(ServiceWrapper(service))
}
type Inner<C, Req, Res, Err, InitErr> = Box<
NewService<
C,
Request = Req,
Response = Res,
Error = Err,
InitError = InitErr,
Service = BoxedService<Req, Res, Err>,
Future = Box<Future<Item = BoxedService<Req, Res, Err>, Error = InitErr>>,
>,
>;
pub struct BoxedNewService<C, Req, Res, Err, InitErr>(Inner<C, Req, Res, Err, InitErr>);
impl<C, Req, Res, Err, InitErr> NewService<C> for BoxedNewService<C, Req, Res, Err, InitErr>
where
Req: 'static,
Res: 'static,
Err: 'static,
InitErr: 'static,
{
type Request = Req;
type Response = Res;
type Error = Err;
type InitError = InitErr;
type Service = BoxedService<Req, Res, Err>;
type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
fn new_service(&self, cfg: &C) -> Self::Future {
self.0.new_service(cfg)
}
}
struct NewServiceWrapper<C, T: NewService<C>> {
service: T,
_t: std::marker::PhantomData<C>,
}
impl<C, T, Req, Res, Err, InitErr> NewService<C> for NewServiceWrapper<C, T>
where
Req: 'static,
Res: 'static,
Err: 'static,
InitErr: 'static,
T: NewService<C, Request = Req, Response = Res, Error = Err, InitError = InitErr>,
T::Future: 'static,
T::Service: 'static,
<T::Service as Service>::Future: 'static,
{
type Request = Req;
type Response = Res;
type Error = Err;
type InitError = InitErr;
type Service = BoxedService<Req, Res, Err>;
type Future = Box<Future<Item = Self::Service, Error = Self::InitError>>;
fn new_service(&self, cfg: &C) -> Self::Future {
Box::new(
self.service
.new_service(cfg)
.into_future()
.map(ServiceWrapper::boxed),
)
}
}
struct ServiceWrapper<T: Service>(T);
impl<T> ServiceWrapper<T>
where
T: Service + 'static,
T::Future: 'static,
{
fn boxed(service: T) -> BoxedService<T::Request, T::Response, T::Error> {
Box::new(ServiceWrapper(service))
}
}
impl<T, Req, Res, Err> Service for ServiceWrapper<T>
where
T: Service<Request = Req, Response = Res, Error = Err>,
T::Future: 'static,
{
type Request = Req;
type Response = Res;
type Error = Err;
type Future = Box<Future<Item = Self::Response, Error = Self::Error>>;
fn poll_ready(&mut self) -> Poll<(), Self::Error> {
self.0.poll_ready()
}
fn call(&mut self, req: Self::Request) -> Self::Future {
Box::new(self.0.call(req))
}
}
|
use util::*;
use BitSetLike;
/// An `Iterator` over a [`BitSetLike`] structure.
///
/// [`BitSetLike`]: ../trait.BitSetLike.html
#[derive(Debug)]
pub struct BitIter<T> {
set: T,
masks: [usize; 4],
prefix: [u32; 3],
}
impl<T> BitIter<T> {
/// Creates a new `BitIter`. You usually don't call this function
/// but just [`.iter()`] on a bit set.
///
/// [`.iter()`]: ../trait.BitSetLike.html#method.iter
pub fn new(set: T, masks: [usize; 4], prefix: [u32; 3]) -> Self {
BitIter {
set: set,
masks: masks,
prefix: prefix,
}
}
}
impl<T> Iterator for BitIter<T>
where T: BitSetLike
{
type Item = Index;
fn next(&mut self) -> Option<Self::Item> {
loop {
if self.masks[0] != 0 {
let bit = self.masks[0].trailing_zeros();
self.masks[0] &= !(1 << bit);
return Some(self.prefix[0] | bit);
}
if self.masks[1] != 0 {
let bit = self.masks[1].trailing_zeros();
self.masks[1] &= !(1 << bit);
let idx = self.prefix[1] | bit;
self.masks[0] = self.set.layer0(idx as usize);
self.prefix[0] = idx << BITS;
continue;
}
if self.masks[2] != 0 {
let bit = self.masks[2].trailing_zeros();
self.masks[2] &= !(1 << bit);
let idx = self.prefix[2] | bit;
self.masks[1] = self.set.layer1(idx as usize);
self.prefix[1] = idx << BITS;
continue;
}
if self.masks[3] != 0 {
let bit = self.masks[3].trailing_zeros();
self.masks[3] &= !(1 << bit);
self.masks[2] = self.set.layer2(bit as usize);
self.prefix[2] = bit << BITS;
continue;
}
return None;
}
}
}
|
use crate::bryggio::{process, recipe::RecipeSrc, Recipe};
use beerxml;
use brew_calculator::ibu;
use std::convert::From;
impl From<beerxml::Recipe> for Recipe<BeerXmlSrc> {
fn from(beerxml_recipe: beerxml::Recipe) -> Self {
Recipe {
name: beerxml_recipe.name,
type_: beerxml_recipe.type_,
style: beerxml_recipe.style,
brewer: beerxml_recipe.brewer,
asst_brewer: beerxml_recipe.asst_brewer,
equipment: beerxml_recipe.equipment,
batch_size: beerxml_recipe.batch_size,
// Both gravity measures should be inferred
// from grain bill, efficiency et al.
pre_boil_gravity: None,
og: beerxml_recipe.og,
fg: beerxml_recipe.fg,
efficiency: beerxml_recipe.efficiency,
hops: beerxml_recipe.hops.hop,
fermentables: beerxml_recipe.fermentables.fermentable,
miscs: beerxml_recipe.miscs.misc,
yeasts: beerxml_recipe.yeasts.yeast,
waters: beerxml_recipe.waters.water,
mash: process::Mash {},
boil: process::Boil::from_beerxml_recipe(
beerxml_recipe.boil_size,
beerxml_recipe.boil_time,
),
fermentation: process::Fermentation {},
carbonation: process::Carbonation {},
notes: beerxml_recipe.notes,
taste_notes: beerxml_recipe.taste_notes,
taste_rating: beerxml_recipe.taste_rating,
date: beerxml_recipe.date,
ibu_method: beerxml_recipe.ibu_method.unwrap_or_default(),
recipe_src: BeerXmlSrc {
ibu_method: beerxml_recipe.ibu_method,
},
}
}
}
/// Original values in the BeerXML source recipe
///
/// Enables faithful translation back to BeerXML.
#[derive(Debug, Clone, Copy)]
pub struct BeerXmlSrc {
ibu_method: Option<ibu::Method>,
}
impl RecipeSrc for BeerXmlSrc {}
|
//! divrulesanddescription.rs - renders the div that shows rules and descriptions
//! All is a static content. Great for implementing dodrio cache.
//region: use
use dodrio::builder::{br, text};
use dodrio::bumpalo::{self, Bump};
use dodrio::{Node, Render};
use typed_html::dodrio;
//endregion
///Text of game rules.
///Multiline string literal just works.
///End of line in the code is simply and intuitively end of line in the string.
///The special character \ at the end of the line in code means that it is NOT the end of the line for the string.
///The escape sequence \n means end of line also. For doublequote simply \" .
const GAME_RULES:& str = "This game is for many players. More players - more fun.
It is fun to play only on smartphones. It works in all modern browsers.
All the players must open this web app to allow communication.
Put all the smartphones on the table near each other, so all players can see them and touch \
them. It should look like a board game at this point.
The first player clicks on 'Invite for play?'.
He can choose different types of game visuals: alphabet, animal, playing cards,...
Other players then see on the screen 'Click here to Accept play!'.
Player1 sees how many players have accepted. Then he starts the game.
On the screen under the grid are clear signals which player plays and which waits.
Player1 flips over two cards with two clicks. This cards can be on any smartphone. \
The cards are accompanied by sounds and text on the screen.
If the cards do not match, the other player clicks on 'Click here to Take your turn' and both cards \
are flipped back face down. Then it is his turn and he clicks to flip over his two cards.
If the cards match, they are left face up permanently and the player receives a point. He continues \
to play, he opens the next two cards.
The game is over when all the cards are permanently face up.
Click on \"Play again?\" to re-start the game. ";
///game description
const GAME_DESCRIPTION:& str = "Learning to use Rust Wasm/WebAssembly with Dodrio Virtual Dom and WebSockets communication - fourth iteration.";
///Render Component: The static parts can be cached easily.
pub struct RulesAndDescription {}
impl Render for RulesAndDescription {
///This rendering will be rendered and then cached . It will not be rerendered untill invalidation.
///In this case I don't need to invalidate because it is a static content.
fn render<'a, 'bump>(&'a self, bump: &'bump Bump) -> Node<'bump>
where
'a: 'bump,
{
dodrio!(bump,
<div>
<h4>
{text_with_br_newline(GAME_DESCRIPTION,bump)}
</h4>
<h2>
{vec![text(
bumpalo::format!(in bump, "Memory game rules: {}", "").into_bump_str(),
)]}
</h2>
<h4>
{text_with_br_newline(GAME_RULES, bump)}
</h4>
<h6>
{vec![text(bumpalo::format!(in bump, "Learning Rust programming: {}", "").into_bump_str(),)]}
<a href= "https://github.com/LucianoBestia/mem4_game" target="_blank">
{vec![text(bumpalo::format!(in bump, "https://github.com/LucianoBestia/mem4_game{}", "").into_bump_str(),)]}
</a>
</h6>
</div>
)
}
}
///change the newline lines ending into <br> node
fn text_with_br_newline<'a>(txt: &'a str, bump: &'a Bump) -> Vec<Node<'a>> {
let mut vec_text_node = Vec::new();
let spl = txt.lines();
for part in spl {
vec_text_node.push(text(part));
vec_text_node.push(br(bump).finish());
}
vec_text_node
}
|
use ::rayon::prelude::*;
use ::rayon::slice::ParallelSliceMut;
use ::std::sync::Mutex;
use crate::util::Point;
use crate::util::Minimum;
#[allow(dead_code)]
fn xsort_ser(points: &mut [Point]) -> (Point, Point) {
points.sort_by(|p1, p2| p1.x.partial_cmp(&p2.x).unwrap());
let mut minimum = Minimum::new(
points[0].clone(),
points[1].clone(),
);
for i in 0..points.len() {
let p1 = points[i];
for j in (i + 1)..points.len() {
let p2 = points[j];
if p2.x - p1.x > minimum.dist1 {
break;
}
if p1.dist2(&p2) < minimum.dist2 {
minimum = Minimum::new(
p1.clone(),
p2.clone(),
);
}
}
}
(minimum.point1, minimum.point2)
}
#[allow(dead_code)]
pub fn xsort_par(points: &mut [Point]) -> (Point, Point) {
let initial_search_preference = 1;
let batch_size = 32;
// Sort by X-coordinate
points.par_sort_unstable_by(|p1, p2| p1.x.partial_cmp(&p2.x).unwrap());
let length = points.len();
// Find how much to do serially
let mut initial_minimum = Minimum::new(
points[0].clone(),
points[1].clone(),
);
let mut initial_search = length % batch_size;
while initial_search < initial_search_preference {
initial_search += batch_size;
}
if initial_search > length {
initial_search = length;
}
let batch_count = (length - initial_search) / batch_size;
// Do some serial searching at the end, to set the initial minimum lower
let initial_search = if length < initial_search_preference { length } else { initial_search_preference };
for i in (length - initial_search)..length {
let p1 = points[i];
for j in (i + 1)..length {
let p2 = points[j];
if p2.x - p1.x > initial_minimum.dist1 {
break;
}
if p1.dist2(&p2) < initial_minimum.dist2 {
initial_minimum = Minimum::new(
p1.clone(),
p2.clone(),
);
}
}
}
let global_minimum = Mutex::new(initial_minimum);
// Use parallel search for the rest of it
(0..batch_count).into_par_iter()
.for_each(|batch_nr| {
let mut local_minimum: Minimum = {
(global_minimum.lock().unwrap()).clone()
};
let offset = batch_nr * batch_size;
for i in offset..(offset + batch_size) {
let p1 = points[i];
for j in (i + 1)..length {
let p2 = points[j];
if p2.x - p1.x > local_minimum.dist1 {
break;
}
if p1.dist2(&p2) < local_minimum.dist2 {
// println!("Potentially updating minimum to {}", p1.dist2(&p2).sqrt());
let mut global_minimum_ref = global_minimum.lock().unwrap();
if p1.dist2(&p2) < global_minimum_ref.dist2 {
// println!(" Definitely updating");
*global_minimum_ref = Minimum::new(
p1.clone(),
p2.clone(),
);
}
local_minimum = global_minimum_ref.clone();
}
}
}
});
// Step 3: profit
{
let global_minimum_ref = global_minimum.lock().unwrap();
(global_minimum_ref.point1, global_minimum_ref.point2)
}
}
|
//! `tcplistener` provide an interface to establish tcp socket server.
use crate::{Handle, IpAddress};
extern "Rust" {
fn sys_tcp_listener_accept(port: u16) -> Result<(Handle, IpAddress, u16), ()>;
}
/// Wait for connection at specified address.
#[deprecated(since = "0.3.0", note = "please use new BSD socket interface")]
pub fn accept(port: u16) -> Result<(Handle, IpAddress, u16), ()> {
unsafe { sys_tcp_listener_accept(port) }
}
|
extern crate gunship;
extern crate rand;
use std::collections::VecDeque;
use std::f32::consts::PI;
use gunship::*;
const ENTITIES_TO_CREATE: usize = 10_000;
const ENTITIES_TO_DESTROY: usize = 1_000;
fn main() {
let mut engine = Engine::new();
engine.register_system(CreateDestroySystem {
entities: VecDeque::new(),
});
setup_scene(engine.scene_mut());
engine.main_loop();
}
fn setup_scene(scene: &mut Scene) {
scene.resource_manager().set_resource_path("examples/");
scene.resource_manager().load_model("meshes/cube.dae").unwrap();
let mut transform_manager = scene.get_manager_mut::<TransformManager>();
let mut camera_manager = scene.get_manager_mut::<CameraManager>();
let mut light_manager = scene.get_manager_mut::<LightManager>();
// Create camera.
{
let camera = scene.create_entity();
let mut camera_transform = transform_manager.assign(camera);
camera_transform.set_position(Point::new(0.0, 0.0, 30.0));
camera_transform.look_at(Point::origin(), Vector3::new(0.0, 0.0, -1.0));
camera_manager.assign(
camera,
Camera::new(
PI / 3.0,
1.0,
0.001,
100.0));
}
// Create light.
{
let light = scene.create_entity();
transform_manager.assign(light);
light_manager.assign(
light,
Light::Point(PointLight {
position: Point::origin()
}));
}
}
#[derive(Debug, Clone)]
struct CreateDestroySystem {
entities: VecDeque<Entity>,
}
impl System for CreateDestroySystem {
fn update(&mut self, scene: &Scene, _delta: f32) {
let mut transform_manager = scene.get_manager_mut::<TransformManager>();
let mut mesh_manager = scene.get_manager_mut::<MeshManager>();
while self.entities.len() < ENTITIES_TO_CREATE {
let entity = scene.create_entity();
let mut transform = transform_manager.assign(entity);
transform.set_position(Point::new(rand::random::<f32>() * 30.0 - 15.0, rand::random::<f32>() * 30.0 - 15.0, 0.0));
mesh_manager.assign(entity, "cube.pCube1");
self.entities.push_back(entity);
}
for _ in 0..ENTITIES_TO_DESTROY {
let entity = self.entities.pop_front().unwrap();
// scene.destroy_entity(entity); // SOON...
mesh_manager.destroy_immediate(entity);
transform_manager.destroy_immediate(entity);
}
}
}
|
use std::env;
use std::fs::File;
use std::io::Write;
use std::path::Path;
use man::prelude::*;
use regex::Regex;
use yaml_rust::yaml::Hash;
use yaml_rust::{Yaml, YamlLoader};
fn s2y<T: ToString>(s: T) -> Yaml {
Yaml::String(s.to_string())
}
fn parse_str<T: ToString>(a: &Hash, k: T) -> String {
let s = a.get(&s2y(k));
match s {
Some(ele) => ele.as_str().unwrap().to_string(),
None => "".to_string(),
}
}
fn set_authors(p: Manual) -> Manual {
let authors = env::var("CARGO_PKG_AUTHORS").unwrap();
let re = Regex::new(r"([\w|\s]+)\s+<([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9]+)>").unwrap();
re.captures_iter(&authors)
.map(|x| {
(
x.get(1).map_or("", |m| m.as_str()),
x.get(2).map_or("", |m| m.as_str()),
)
})
.fold(p, |p, c| p.author(Author::new(c.0).email(c.1)))
}
fn set_args(mut p: Manual, y: &Yaml) -> Manual {
let args = y["args"].as_vec().unwrap();
for karg in args {
let (key, val) = karg.as_hash().unwrap().iter().next().unwrap();
let key = key.as_str().unwrap();
let arg = val.as_hash().unwrap();
if arg.get(&s2y("index")).is_none() {
let takes_value = arg.get(&s2y("takes_value"));
if takes_value.is_none() || !takes_value.unwrap().as_bool().unwrap() {
let mut f = Flag::new()
.long(parse_str(&arg, "long").as_str())
.help(parse_str(&arg, "help").as_str());
let short = parse_str(&arg, "short");
if short != "" {
f = f.short(short.as_str());
}
p = p.flag(f);
} else {
let o_val = parse_str(&arg, "value_name");
let key = if o_val != "" { o_val.as_str() } else { key };
let mut o = Opt::new(key)
.long(parse_str(&arg, "long").as_str())
.help(parse_str(&arg, "help").as_str());
let short = parse_str(&arg, "short");
let default_value = parse_str(&arg, "default_value");
if short != "" {
o = o.short(short.as_str());
}
if default_value != "" {
o = o.default_value(default_value.as_str());
}
p = p.option(o);
}
} else {
p = p.arg(Arg::new(key));
}
}
p
}
fn generate_manpage(yml: &Yaml, trg_dir: &Path) -> std::io::Result<()> {
let out_location = trg_dir.join("git-req.1");
let page = Manual::new("git-req").about(yml["about"].as_str().unwrap());
let page = set_authors(page);
let page = set_args(page, yml);
let mut output = File::create(out_location)?;
write!(output, "{}", page.render())?;
Ok(())
}
fn main() -> std::io::Result<()> {
let trg_dir = match env::var("CARGO_TARGET_DIR") {
Ok(s) => s,
Err(_) => String::from("target"),
};
let trg_dir = Path::new(&trg_dir).join(&env::var("PROFILE").unwrap());
let yml = YamlLoader::load_from_str(include_str!("cli-flags.yml")).unwrap();
let yml = yml.get(0).unwrap();
generate_manpage(yml, &trg_dir)?;
Ok(())
}
|
//! DAG-JSON codec.
use crate::ipld::{BlockError, Ipld};
use cid::Cid;
use core::convert::TryFrom;
use serde::de::Error as SerdeError;
use serde::{de, ser, Deserialize, Serialize};
use serde_json::ser::Serializer;
use serde_json::Error;
use std::collections::BTreeMap;
use std::fmt;
/// Json codec.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct DagJsonCodec;
impl DagJsonCodec {
pub fn encode(ipld: &Ipld) -> Result<Box<[u8]>, BlockError> {
json_encode(ipld).map_err(|e| BlockError::CodecError(e.into()))
}
pub fn decode(data: &[u8]) -> Result<Ipld, BlockError> {
json_decode(data).map_err(|e| BlockError::CodecError(e.into()))
}
}
const LINK_KEY: &str = "/";
pub fn json_encode(ipld: &Ipld) -> Result<Box<[u8]>, Error> {
let mut writer = Vec::with_capacity(128);
let mut ser = Serializer::new(&mut writer);
serialize(ipld, &mut ser)?;
Ok(writer.into_boxed_slice())
}
pub fn json_decode(data: &[u8]) -> Result<Ipld, Error> {
let mut de = serde_json::Deserializer::from_slice(data);
deserialize(&mut de)
}
fn serialize<S>(ipld: &Ipld, ser: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
match &ipld {
Ipld::Null => ser.serialize_none(),
Ipld::Bool(bool) => ser.serialize_bool(*bool),
Ipld::Integer(i128) => ser.serialize_i128(*i128),
Ipld::Float(f64) => ser.serialize_f64(*f64),
Ipld::String(string) => ser.serialize_str(string),
Ipld::Bytes(bytes) => ser.serialize_bytes(bytes),
Ipld::List(list) => {
let wrapped = list.iter().map(Wrapper);
ser.collect_seq(wrapped)
}
Ipld::Map(map) => {
let wrapped = map.iter().map(|(key, ipld)| (key, Wrapper(ipld)));
ser.collect_map(wrapped)
}
Ipld::Link(link) => {
let value = base64::encode(&link.to_bytes());
let mut map = BTreeMap::new();
map.insert("/", value);
ser.collect_map(map)
}
}
}
fn deserialize<'de, D>(deserializer: D) -> Result<Ipld, D::Error>
where
D: de::Deserializer<'de>,
{
deserializer.deserialize_any(JSONVisitor)
}
// Needed for `collect_seq` and `collect_map` in Seserializer
struct Wrapper<'a>(&'a Ipld);
impl<'a> Serialize for Wrapper<'a> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: ser::Serializer,
{
serialize(self.0, serializer)
}
}
// serde deserializer visitor that is used by Deseraliazer to decode
// json into IPLD.
struct JSONVisitor;
impl<'de> de::Visitor<'de> for JSONVisitor {
type Value = Ipld;
fn expecting(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt.write_str("any valid JSON value")
}
#[inline]
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
where
E: de::Error,
{
self.visit_string(String::from(value))
}
#[inline]
fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::String(value))
}
#[inline]
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
self.visit_byte_buf(v.to_owned())
}
#[inline]
fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Bytes(v))
}
#[inline]
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Integer(v.into()))
}
#[inline]
fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Integer(v.into()))
}
#[inline]
fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Integer(v))
}
#[inline]
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Bool(v))
}
#[inline]
fn visit_none<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
self.visit_unit()
}
#[inline]
fn visit_unit<E>(self) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Null)
}
#[inline]
fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: de::SeqAccess<'de>,
{
let mut vec: Vec<WrapperOwned> = Vec::new();
while let Some(elem) = visitor.next_element()? {
vec.push(elem);
}
let unwrapped = vec.into_iter().map(|WrapperOwned(ipld)| ipld).collect();
Ok(Ipld::List(unwrapped))
}
#[inline]
fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
where
V: de::MapAccess<'de>,
{
let mut values: Vec<(String, WrapperOwned)> = Vec::new();
while let Some((key, value)) = visitor.next_entry()? {
values.push((key, value));
}
// JSON Object represents IPLD Link if it is `{ "/": "...." }` therefor
// we valiadet if that is the case here.
if let Some((key, WrapperOwned(Ipld::String(value)))) = values.first() {
if key == LINK_KEY && values.len() == 1 {
let link = base64::decode(value).map_err(SerdeError::custom)?;
let cid = Cid::try_from(link).map_err(SerdeError::custom)?;
return Ok(Ipld::Link(cid));
}
}
let unwrapped = values
.into_iter()
.map(|(key, WrapperOwned(value))| (key, value));
Ok(Ipld::Map(unwrapped.collect()))
}
#[inline]
fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
where
E: de::Error,
{
Ok(Ipld::Float(v))
}
}
// Needed for `visit_seq` and `visit_map` in Deserializer
/// We cannot directly implement `serde::Deserializer` for `Ipld` as it is a remote type.
/// Instead wrap it into a newtype struct and implement `serde::Deserialize` for that one.
/// All the deserializer does is calling the `deserialize()` function we defined which returns
/// an unwrapped `Ipld` instance. Wrap that `Ipld` instance in `Wrapper` and return it.
/// Users of this wrapper will then unwrap it again so that they can return the expected `Ipld`
/// instance.
struct WrapperOwned(Ipld);
impl<'de> Deserialize<'de> for WrapperOwned {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
let deserialized = deserialize(deserializer);
// Better version of Ok(Wrapper(deserialized.unwrap()))
deserialized.map(Self)
}
}
|
use crate::prelude::*;
use std::os::raw::c_void;
use std::ptr;
#[repr(C)]
#[derive(Debug)]
pub struct VkRenderPassBeginInfo {
pub sType: VkStructureType,
pub pNext: *const c_void,
pub renderPass: VkRenderPass,
pub framebuffer: VkFramebuffer,
pub renderArea: VkRect2D,
pub clearValueCount: u32,
pub pClearValues: *const VkClearValue,
}
impl VkRenderPassBeginInfo {
pub fn new(
renderpass: VkRenderPass,
framebuffer: VkFramebuffer,
render_area: VkRect2D,
clear_values: &[VkClearValue],
) -> Self {
VkRenderPassBeginInfo {
sType: VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
pNext: ptr::null(),
renderPass: renderpass,
framebuffer,
renderArea: render_area,
clearValueCount: clear_values.len() as u32,
pClearValues: clear_values.as_ptr(),
}
}
}
|
// This file is part of file-descriptors. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/file-descriptors/master/COPYRIGHT. No part of file-descriptors, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright ยฉ 2019 The developers of file-descriptors. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/file-descriptors/master/COPYRIGHT.
/// A reactor 'reacts' to events becoming ready from an epoll instance.
pub trait Reactor: Sized
{
/// An associated file descriptor type.
type FileDescriptor: AsRawFd;
/// Data to pass to `do_initial_input_and_output_and_register_with_epoll_if_necesssary()`.
type RegistrationData: Sized;
/// Register with epoll.
fn do_initial_input_and_output_and_register_with_epoll_if_necesssary<A: Arena<Self>, EPR: EventPollRegister>(event_poll_register: &EPR, arena: &A, reactor_compressed_type_identifier: CompressedTypeIdentifier, registration_data: Self::RegistrationData) -> Result<(), EventPollRegistrationError>;
/// React to events becoming ready.
///
/// If `Ok(true)` is returned then the file descriptor is de-registered and closed; if `Ok(false)` is returned then it isn't.
/// If an `Err` is returned then all activity is cut short; any dequeued events not yet 'reacted' to are discarded.
fn react(&mut self, event_flags: EPollEventFlags, terminate: &impl Terminate) -> Result<bool, String>;
}
|
use ctpop::ctpop32;
/**
* Counts the number of leading zero bits in an unsigned 32-bit integer.
*/
pure fn lzc32(m: u32) -> u32 {
let mut x = copy m;
x |= (x >> 1);
x |= (x >> 2);
x |= (x >> 4);
x |= (x >> 8);
x |= (x >> 16);
return(32 - ctpop32(x));
}
#[test]
fn test_lzc32_1() {
assert(lzc32(0x0) == 32);
assert(lzc32(0x1) == 31);
assert(lzc32(0x7F) == 25);
assert(lzc32(0xFF) == 24);
assert(lzc32(0x7FFF) == 17);
assert(lzc32(0xFFFF) == 16);
assert(lzc32(0x7FFFFF) == 9);
assert(lzc32(0xFFFFFF) == 8);
assert(lzc32(0x7FFFFFFF) == 1);
assert(lzc32(0xFFFFFFFF) == 0);
} |
use crypto::{
encryption::ElGamal,
helper::Helper,
proofs::{decryption::DecryptionProof, keygen::KeyGenerationProof},
random::Random,
types::Cipher as BigCipher,
};
use hex_literal::hex;
use num_bigint::BigUint;
use pallet_mixnet::types::{Cipher, PublicKeyShare, Wrapper};
use sp_keyring::{sr25519::sr25519::Pair, AccountKeyring};
use substrate_subxt::{Client, PairSigner};
use substrate_subxt::{ClientBuilder, Error, NodeTemplateRuntime};
use super::substrate::rpc::{get_ciphers, store_public_key_share, submit_partial_decryptions};
async fn init() -> Result<Client<NodeTemplateRuntime>, Error> {
env_logger::init();
let url = "ws://127.0.0.1:9944";
let client = ClientBuilder::<NodeTemplateRuntime>::new()
.set_url(url)
.build()
.await?;
Ok(client)
}
fn get_sealer(sealer: String) -> (Pair, [u8; 32]) {
// get the sealer and sealer_id
if sealer == "bob" {
return (
AccountKeyring::Bob.pair(),
hex!("8eaf04151687736326c9fea17e25fc5287613693c912909cb226aa4794f26a48").into(),
);
} else {
return (
AccountKeyring::Charlie.pair(),
hex!("90b5ab205c6974c9ea841be688864633dc9ca8a357843eeacf2314649965fe22").into(),
);
};
}
pub async fn keygen(vote: String, sk_as_string: String, sealer: String) -> Result<(), Error> {
// init substrate client
let client = init().await?;
// create private and public key
let (params, sk, pk) = Helper::setup_lg_system_with_sk(sk_as_string.as_bytes());
// get the sealer and sealer_id
let (sealer, sealer_id): (Pair, [u8; 32]) = get_sealer(sealer);
// create public key share + proof
let r = Random::get_random_less_than(¶ms.q());
let proof = KeyGenerationProof::generate(¶ms, &sk.x, &pk.h, &r, &sealer_id);
let pk_share = PublicKeyShare {
proof: proof.clone().into(),
pk: pk.h.to_bytes_be(),
};
let vote_id = vote.as_bytes().to_vec();
// submit the public key share + proof
let signer = PairSigner::<NodeTemplateRuntime, Pair>::new(sealer);
let store_public_key_share_response =
store_public_key_share(&client, &signer, vote_id, pk_share).await?;
println!(
"store_public_key_share_response: {:?}",
store_public_key_share_response.events[0].variant
);
Ok(())
}
pub async fn decrypt(
vote: String,
question: String,
sk_as_string: String,
sealer: String,
) -> Result<(), Error> {
// init substrate client
let client = init().await?;
// create private and public key
let (params, sk, pk) = Helper::setup_lg_system_with_sk(sk_as_string.as_bytes());
// get the sealer and sealer_id
let (sealer, sealer_id): (Pair, [u8; 32]) = get_sealer(sealer);
// fetch the encrypted votes from chain
let vote_id = vote.as_bytes().to_vec();
let topic_id = question.as_bytes().to_vec();
let nr_of_shuffles = 3;
let encryptions: Vec<Cipher> = get_ciphers(&client, topic_id.clone(), nr_of_shuffles).await?;
let encryptions: Vec<BigCipher> = Wrapper(encryptions).into();
// get partial decryptions
let partial_decryptions = encryptions
.iter()
.map(|cipher| ElGamal::partial_decrypt_a(cipher, &sk))
.collect::<Vec<BigUint>>();
// convert the decrypted shares: Vec<BigUint> to Vec<Vec<u8>>
let shares: Vec<Vec<u8>> = partial_decryptions
.iter()
.map(|c| c.to_bytes_be())
.collect::<Vec<Vec<u8>>>();
// create proof using public and private key share
let r = Random::get_random_less_than(¶ms.q());
let proof = DecryptionProof::generate(
¶ms,
&sk.x,
&pk.h.into(),
&r,
encryptions,
partial_decryptions,
&sealer_id,
);
// submit the partial decryption + proof
let signer = PairSigner::<NodeTemplateRuntime, Pair>::new(sealer);
let response = submit_partial_decryptions(
&client,
&signer,
vote_id,
topic_id,
shares,
proof.into(),
nr_of_shuffles,
)
.await?;
println!("response: {:?}", response.events[0].variant);
Ok(())
}
|
fn main() {
let stdin = std::io::stdin();
let mut rd = ProconReader::new(stdin.lock());
let n: usize = rd.get();
let a: Vec<usize> = (0..n).map(|_| { rd.get() }).collect();
let mo: usize = 998244353;
use mint::Mint;
let mut ans = Mint::zero(mo);
let mut left_cnt = vec![0; n]; // 0..j ใฎ็ฏๅฒใง a[j] ใใๅคงใใๆฐใฎๅๆฐ
let mut left_sum = vec![Mint::zero(mo); n]; // 0..j ใฎ็ฏๅฒใง a[j] ใใๅคงใใๆฐใฎ็ทๅ
let mut right_cnt = vec![0; n]; // (j+1)..n ใฎ็ฏๅฒใง a[j] ใใๅฐใใๆฐใฎๅๆฐ
let mut right_sum = vec![Mint::zero(mo); n]; // (j+1)..n ใฎ็ฏๅฒใง a[j] ใใๅฐใใๆฐใฎ็ทๅ
{
let mut ai = a.iter().zip(0..n).map(|(&x, i)| (x, i)).collect::<Vec<_>>();
ai.sort_by(|(x, i), (y, j)| {
if x == y {
i.cmp(j)
} else {
x.cmp(y)
}
});
let mut seg = SegmentTree::new(n, 0usize, |x, y| x + y);
let mut teg = SegmentTree::new(n, Mint::zero(mo), |x, y| x + y);
for (x, i) in ai {
right_cnt[i] = seg.fold((i + 1)..n);
right_sum[i] = teg.fold((i + 1)..n);
seg.update(i, 1);
teg.update(i, Mint::new(x, mo));
}
}
{
let mut ai = a.iter().zip(0..n).map(|(&x, i)| (x, i)).collect::<Vec<_>>();
ai.sort_by(|(x, i), (y, j)| {
if x == y {
j.cmp(i)
} else {
y.cmp(x)
}
});
let mut seg = SegmentTree::new(n, 0usize, |x, y| x + y);
let mut teg = SegmentTree::new(n, Mint::zero(mo), |x, y| x + y);
for (x, i) in ai {
left_cnt[i] = seg.fold(0..i);
left_sum[i] = teg.fold(0..i);
seg.update(i, 1);
teg.update(i, Mint::new(x, mo));
}
}
macro_rules! add {
($a:expr, $b:expr) => {
$a = $a + $b;
}
}
for j in 0..n {
let l_c = left_cnt[j];
let r_c = right_cnt[j];
let l_s = left_sum[j];
let r_s = right_sum[j];
add!(ans, a[j] * l_c * r_c % mo);
add!(ans, l_s * r_c);
add!(ans, r_s * l_c);
}
println!("{}", ans);
}
struct SegmentTree<T, F> {
n: usize,
dat: Vec<T>,
e: T,
multiply: F,
}
#[allow(dead_code)]
impl<T, F> SegmentTree<T, F>
where
T: Clone + Copy,
F: Fn(T, T) -> T,
{
fn new(n: usize, e: T, multiply: F) -> Self {
let n = n.next_power_of_two();
Self {
n,
dat: vec![e; n * 2 - 1],
e,
multiply,
}
}
fn get(&self, i: usize) -> T {
self.dat[i + self.n - 1]
}
fn update(&mut self, i: usize, x: T) {
let mut k = i + self.n - 1;
self.dat[k] = x;
while k > 0 {
k = (k - 1) / 2;
self.dat[k] = (self.multiply)(self.dat[k * 2 + 1], self.dat[k * 2 + 2]);
}
}
fn fold(&self, range: std::ops::Range<usize>) -> T {
self._fold(&range, 0, 0..self.n)
}
fn _fold(
&self,
range: &std::ops::Range<usize>,
i: usize,
i_range: std::ops::Range<usize>,
) -> T {
if range.end <= i_range.start || i_range.end <= range.start {
return self.e;
}
if range.start <= i_range.start && i_range.end <= range.end {
return self.dat[i];
}
let m = (i_range.start + i_range.end) / 2;
(self.multiply)(
self._fold(range, i * 2 + 1, i_range.start..m),
self._fold(range, i * 2 + 2, m..i_range.end),
)
}
}
#[allow(dead_code)]
mod mint {
use std::ops::{Add, BitAnd, Div, Mul, Rem, Shr, Sub};
#[derive(Copy, Clone, Debug)]
pub struct Mint<T> {
x: T,
mo: T,
}
impl<T> Mint<T>
where
T: Copy,
{
pub fn new(x: T, mo: T) -> Mint<T> {
Mint { x, mo }
}
}
impl<T> Mint<T>
where
T: Copy,
{
pub fn val(&self) -> T {
self.x
}
pub fn mo(&self) -> T {
self.mo
}
}
impl<T> Add<T> for Mint<T>
where
T: Copy,
T: Add<Output=T>,
T: Rem<Output=T>,
{
type Output = Mint<T>;
fn add(self, rhs: T) -> Mint<T> {
Mint::new((self.val() + rhs % self.mo()) % self.mo(), self.mo())
}
}
impl<T> Add<Mint<T>> for Mint<T>
where
T: Copy,
Mint<T>: Add<T, Output=Mint<T>>,
{
type Output = Mint<T>;
fn add(self, rhs: Mint<T>) -> Mint<T> {
self + rhs.val()
}
}
impl<T> Sub<T> for Mint<T>
where
T: Copy,
T: Add<Output=T>,
T: Sub<Output=T>,
T: Rem<Output=T>,
{
type Output = Mint<T>;
fn sub(self, rhs: T) -> Mint<T> {
Mint::new(
(self.val() + self.mo() - rhs % self.mo()) % self.mo(),
self.mo(),
)
}
}
impl<T> Sub<Mint<T>> for Mint<T>
where
T: Copy,
Mint<T>: Sub<T, Output=Mint<T>>,
{
type Output = Mint<T>;
fn sub(self, rhs: Mint<T>) -> Mint<T> {
self - rhs.val()
}
}
impl<T> Mul<T> for Mint<T>
where
T: Copy,
T: Mul<Output=T>,
T: Rem<Output=T>,
{
type Output = Mint<T>;
fn mul(self, rhs: T) -> Mint<T> {
Mint::new((self.val() * rhs % self.mo()) % self.mo(), self.mo())
}
}
impl<T> Mul<Mint<T>> for Mint<T>
where
T: Copy,
Mint<T>: Mul<T, Output=Mint<T>>,
{
type Output = Mint<T>;
fn mul(self, rhs: Mint<T>) -> Mint<T> {
self * rhs.val()
}
}
impl<T> Mint<T>
where
T: Copy,
T: Sub<Output=T>,
T: Div<Output=T>,
T: PartialOrd,
T: PartialEq,
T: BitAnd<Output=T>,
T: Shr<Output=T>,
Mint<T>: Mul<Output=Mint<T>>,
{
pub fn pow(self, y: T) -> Mint<T> {
let one = self.mo() / self.mo();
let zero = self.mo() - self.mo();
let mut res = Mint::one(self.mo());
let mut base = self;
let mut exp = y;
while exp > zero {
if (exp & one) == one {
res = res * base;
}
base = base * base;
exp = exp >> one;
}
res
}
}
impl<T> Div<T> for Mint<T>
where
T: Copy,
T: Sub<Output=T>,
T: Div<Output=T>,
T: PartialOrd,
T: PartialEq,
T: BitAnd<Output=T>,
T: Shr<Output=T>,
Mint<T>: Mul<Output=Mint<T>>,
{
type Output = Mint<T>;
fn div(self, rhs: T) -> Mint<T> {
let one = self.mo() / self.mo();
self * Mint::new(rhs, self.mo()).pow(self.mo() - one - one)
}
}
impl<T> Div<Mint<T>> for Mint<T>
where
T: Copy,
Mint<T>: Div<T, Output=Mint<T>>,
{
type Output = Mint<T>;
fn div(self, rhs: Mint<T>) -> Mint<T> {
self / rhs.val()
}
}
impl<T> Mint<T>
where
T: Copy,
T: Div<Output=T>,
Mint<T>: Div<Output=Mint<T>>,
{
pub fn inv(self) -> Mint<T> {
Mint::one(self.mo()) / self
}
}
impl<T> std::fmt::Display for Mint<T>
where
T: Copy + std::fmt::Display,
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
write!(f, "{}", self.val())
}
}
impl<T> Mint<T>
where
T: Copy,
T: Sub<Output=T>,
{
pub fn zero(mo: T) -> Mint<T> {
Mint { x: mo - mo, mo }
}
}
impl<T> Mint<T>
where
T: Copy,
T: Div<Output=T>,
{
pub fn one(mo: T) -> Mint<T> {
Mint { x: mo / mo, mo }
}
}
}
pub struct ProconReader<R: std::io::Read> {
reader: R,
}
impl<R: std::io::Read> ProconReader<R> {
pub fn new(reader: R) -> Self {
Self { reader }
}
pub fn get<T: std::str::FromStr>(&mut self) -> T {
use std::io::Read;
let buf = self
.reader
.by_ref()
.bytes()
.map(|b| b.unwrap())
.skip_while(|&byte| byte == b' ' || byte == b'\n' || byte == b'\r')
.take_while(|&byte| byte != b' ' && byte != b'\n' && byte != b'\r')
.collect::<Vec<_>>();
std::str::from_utf8(&buf)
.unwrap()
.parse()
.ok()
.expect("Parse Error.")
}
}
|
use std::env;
use std::fs::File;
use std::io::{BufRead, BufReader};
fn main() {
let a = env::args().skip(1).next()
.and_then(|s| File::open(s).ok())
.map(|f| BufReader::new(f).lines());
for lines in a {
for line in lines {
println!("{}", line.unwrap());
// println!("{}", line.unwrap_or(String::from("")));
}
}
} |
//! Implementation of gas price estimation.
use crate::conv;
use crate::future::CompatCallFuture;
use futures::compat::Future01CompatExt;
use futures::future::OptionFuture;
use pin_project::{pin_project, project};
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use web3::api::Web3;
use web3::error::Error as Web3Error;
use web3::types::U256;
use web3::Transport;
/// The gas price setting to use.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum GasPrice {
/// The standard estimated gas price from the node, this is usually the
/// median gas price from the last few blocks. This is the default gas price
/// used by transactions.
Standard,
/// A factor of the estimated gas price from the node. `GasPrice::Standard`
/// is similar to `GasPrice::Scaled(1.0)` but because of how the scaling is
/// calculated, `GasPrice::Scaled(1.0)` can lead to some rounding errors
/// caused by converting the estimated gas price from the node to a `f64`
/// and back.
Scaled(f64),
/// Specify a specific gas price to use for the transaction. This will cause
/// the transaction `SendFuture` to not query the node for a gas price
/// estimation.
Value(U256),
}
impl GasPrice {
/// A low gas price. Using this may result in long confirmation times for
/// transactions, or the transactions not being mined at all.
pub fn low() -> Self {
GasPrice::Scaled(0.8)
}
/// A high gas price that usually results in faster mining times.
/// transactions, or the transactions not being mined at all.
pub fn high() -> Self {
GasPrice::Scaled(6.0)
}
/// Returns `Some(value)` if the gas price is explicitly specified, `None`
/// otherwise.
pub fn value(&self) -> Option<U256> {
match self {
GasPrice::Value(value) => Some(*value),
_ => None,
}
}
/// Resolves the gas price into a value. Returns a future that resolves once
/// the gas price is calculated as this may require contacting the node for
/// gas price estimates in the case of `GasPrice::Standard` and
/// `GasPrice::Scaled`.
pub fn resolve<T: Transport>(self, web3: &Web3<T>) -> ResolveGasPriceFuture<T> {
ResolveGasPriceFuture::new(web3, self)
}
/// Resolves the gas price into an `Option<U256>` intendend to be used by a
/// `TransactionRequest`. Note that `TransactionRequest`s gas price default
/// to the node's estimate (i.e. `GasPrice::Standard`) when omitted, so this
/// allows for a small optimization by foregoing a JSON RPC request.
pub fn resolve_for_transaction_request<T: Transport>(
self,
web3: &Web3<T>,
) -> ResolveTransactionRequestGasPriceFuture<T> {
let future = match self {
GasPrice::Standard => None,
_ => Some(self.resolve(web3)),
};
future.into()
}
}
impl Default for GasPrice {
fn default() -> Self {
GasPrice::Standard
}
}
impl From<U256> for GasPrice {
fn from(value: U256) -> Self {
GasPrice::Value(value)
}
}
macro_rules! impl_gas_price_from_integer {
($($t:ty),* $(,)?) => {
$(
impl From<$t> for GasPrice {
fn from(value: $t) -> Self {
GasPrice::Value(value.into())
}
}
)*
};
}
impl_gas_price_from_integer! {
i8, i16, i32, i64, i128, isize,
u8, u16, u32, u64, u128, usize,
}
/// Future for resolving gas prices.
#[must_use = "futures do nothing unless you `.await` or poll them"]
#[pin_project]
pub struct ResolveGasPriceFuture<T: Transport> {
/// The state of the future.
#[pin]
state: ResolveGasPriceState<T>,
}
/// The state of the `ResolveGasPriceFuture`. This type is used to not leak
/// internal implementation details.
#[pin_project]
enum ResolveGasPriceState<T: Transport> {
/// The gas price is known before hand.
Ready(U256),
/// The gas price estimate is being queried with the node. Optinally, the
/// gas price will be scaled once retrieved.
Estimating(#[pin] CompatCallFuture<T, U256>, Option<f64>),
}
impl<T: Transport> ResolveGasPriceFuture<T> {
/// Creates a new future that resolves once the gas price value is computed.
pub fn new(web3: &Web3<T>, gas_price: GasPrice) -> Self {
let state = match gas_price {
GasPrice::Standard => {
ResolveGasPriceState::Estimating(web3.eth().gas_price().compat(), None)
}
GasPrice::Scaled(factor) => {
ResolveGasPriceState::Estimating(web3.eth().gas_price().compat(), Some(factor))
}
GasPrice::Value(value) => ResolveGasPriceState::Ready(value),
};
ResolveGasPriceFuture { state }
}
}
impl<T: Transport> Future for ResolveGasPriceFuture<T> {
type Output = Result<U256, Web3Error>;
#[project]
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
let this = self.project();
#[project]
match this.state.project() {
ResolveGasPriceState::Ready(value) => Poll::Ready(Ok(*value)),
ResolveGasPriceState::Estimating(gas_price, factor) => {
gas_price.poll(cx).map(|gas_price| {
if let Some(factor) = factor {
Ok(scale_gas_price(gas_price?, *factor))
} else {
gas_price
}
})
}
}
}
}
/// A type alias for an optional `ResolveGasPriceFuture` when resolving the gas
/// price for a `TransactionRequest`.
pub type ResolveTransactionRequestGasPriceFuture<T> = OptionFuture<ResolveGasPriceFuture<T>>;
/// Apply a scaling factor to a gas price.
fn scale_gas_price(gas_price: U256, factor: f64) -> U256 {
// NOTE: U256 does not support floating point multiplication we have to
// convert everything to floats to multiply the factor and then convert
// back. We are OK with the loss of precision here.
let gas_price_f = conv::u256_to_f64(gas_price);
conv::f64_to_u256(gas_price_f * factor)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test::prelude::*;
#[test]
fn gas_price_scalling() {
assert_eq!(scale_gas_price(1_000_000.into(), 2.0), 2_000_000.into());
assert_eq!(scale_gas_price(1_000_000.into(), 1.5), 1_500_000.into());
assert_eq!(scale_gas_price(U256::MAX, 2.0), U256::MAX);
}
#[test]
fn resolve_gas_price() {
let mut transport = TestTransport::new();
let web3 = Web3::new(transport.clone());
let gas_price = U256::from(1_000_000);
transport.add_response(json!(gas_price));
assert_eq!(
GasPrice::Standard
.resolve(&web3)
.immediate()
.expect("error resolving gas price"),
gas_price
);
transport.assert_request("eth_gasPrice", &[]);
transport.assert_no_more_requests();
transport.add_response(json!(gas_price));
assert_eq!(
GasPrice::Scaled(2.0)
.resolve(&web3)
.immediate()
.expect("error resolving gas price"),
gas_price * 2
);
transport.assert_request("eth_gasPrice", &[]);
transport.assert_no_more_requests();
assert_eq!(
GasPrice::Value(gas_price)
.resolve(&web3)
.immediate()
.expect("error resolving gas price"),
gas_price
);
transport.assert_no_more_requests();
}
#[test]
fn resolve_gas_price_for_transaction_request() {
let mut transport = TestTransport::new();
let web3 = Web3::new(transport.clone());
let gas_price = U256::from(1_000_000);
assert_eq!(
GasPrice::Standard
.resolve_for_transaction_request(&web3)
.immediate()
.transpose()
.expect("error resolving gas price"),
None
);
transport.assert_no_more_requests();
transport.add_response(json!(gas_price));
assert_eq!(
GasPrice::Scaled(2.0)
.resolve_for_transaction_request(&web3)
.immediate()
.transpose()
.expect("error resolving gas price"),
Some(gas_price * 2),
);
transport.assert_request("eth_gasPrice", &[]);
transport.assert_no_more_requests();
assert_eq!(
GasPrice::Value(gas_price)
.resolve_for_transaction_request(&web3)
.immediate()
.transpose()
.expect("error resolving gas price"),
Some(gas_price)
);
transport.assert_no_more_requests();
}
}
|
use super::{DataHandle, MemoryFS, OpenOptions, VPath, VFS};
use rust_embed::RustEmbed;
pub fn assets_to_vfs<R: RustEmbed>() -> MemoryFS {
let mem = MemoryFS::new();
for path in R::iter() {
let parent = pathutils::parent_path(&path).unwrap();
let mem_path = mem.path(parent);
mem_path.create_dir_inner().unwrap();
let mem_path = mem.path(&path);
let d_file = mem_path
.open_with_options(&OpenOptions::new().write(true).create(true).truncate(true))
.unwrap();
let s_file = R::get(&path).unwrap();
let mut data = d_file.data.0.write().unwrap();
*data = s_file.data.to_vec();
}
mem
}
|
pub mod display;
pub mod input;
pub mod audio;
pub mod config; |
//! ะขะธะฟั ัะตัะตะฝะธะน ะบะพะปะพะฝะฝ, ะฑะฐะปะพะบ, ััะฝะดะฐะผะตะฝัะฝัั
ะฑะฐะปะพะบ
use crate::sig::HasWrite;
use nom::{
bytes::complete::take,
number::complete::{le_f32, le_u8},
IResult,
};
use std::fmt;
#[derive(Debug)]
pub enum Sec {
Rectangle(RectangleSec),
Circle(CircleSec),
Cross(CrossSec),
Ring(RingSec),
Box(BoxSec),
ISec(ISec),
Shelves(ShelvesSec),
}
impl HasWrite for Sec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
match self {
Sec::Rectangle(s) => out.extend(s.write()),
Sec::Circle(s) => out.extend(s.write()),
Sec::Cross(s) => out.extend(s.write()),
Sec::Ring(s) => out.extend(s.write()),
Sec::Box(s) => out.extend(s.write()),
Sec::ISec(s) => out.extend(s.write()),
Sec::Shelves(s) => out.extend(s.write()),
}
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for Sec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match &self {
Sec::Rectangle(r) => write!(f, "Sec: rectangle |{}|", r),
Sec::Circle(r) => write!(f, "Sec: circle |{}|", r),
Sec::Cross(r) => write!(f, "Sec: cross |{}|", r),
Sec::Ring(r) => write!(f, "Sec: ring |{}|", r),
Sec::Box(r) => write!(f, "Sec: box |{}|", r),
Sec::ISec(r) => write!(f, "Sec: bead |{}|", r),
Sec::Shelves(r) => write!(f, "Sec: shelves |{}|", r),
}
}
}
#[derive(Debug)]
pub struct RectangleSec {
b: f32,
h: f32,
flag_f: u8, //ะคะปะฐะณ ะฟะพะดะฑะพัะฐ ัะตัะตะฝะธั. 0=ะฝะตั, 1=ะฟะพะดะฑะพั h, 2=ะฟะพะดะฑะพั b, 3=ะฟะพะดะฑะพั h ะธ b
ws: Vec<u8>, //2b
}
impl HasWrite for RectangleSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.b.to_le_bytes());
out.extend(&self.h.to_le_bytes());
out.extend(&self.flag_f.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for RectangleSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "b: {}, h: {}", &self.b, &self.h)
}
}
#[derive(Debug)]
pub struct CircleSec {
d: f32,
flag_f: u8, //ะคะปะฐะณ ะฟะพะดะฑะพัะฐ ัะตัะตะฝะธั. 0=ะฝะตั, 1=ะฟะพะดะฑะพั
ws: Vec<u8>, //2b
}
impl HasWrite for CircleSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.d.to_le_bytes());
out.extend(&self.flag_f.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for CircleSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "d: {}", &self.d)
}
}
#[derive(Debug)]
pub struct CrossSec {
b1: f32,
b2: f32,
b3: f32,
h1: f32,
h2: f32,
h3: f32,
ws: Vec<u8>, //2b
}
impl HasWrite for CrossSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.b1.to_le_bytes());
out.extend(&self.b2.to_le_bytes());
out.extend(&self.b3.to_le_bytes());
out.extend(&self.h1.to_le_bytes());
out.extend(&self.h2.to_le_bytes());
out.extend(&self.h3.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for CrossSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"b1: {}, b2: {}, b3: {}, h1: {}, h2: {}, h3: {}",
&self.b1, &self.b2, &self.b3, &self.h1, &self.h2, &self.h3,
)
}
}
#[derive(Debug)]
pub struct RingSec {
d: f32,
t: f32,
ws: Vec<u8>, //2b
}
impl HasWrite for RingSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.d.to_le_bytes());
out.extend(&self.t.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for RingSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "d: {}, t: {}", &self.d, &self.t)
}
}
#[derive(Debug)]
pub struct BoxSec {
b: f32,
b1: f32,
h: f32,
h1: f32,
ws: Vec<u8>, //2b
}
impl HasWrite for BoxSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.b.to_le_bytes());
out.extend(&self.b1.to_le_bytes());
out.extend(&self.h.to_le_bytes());
out.extend(&self.h1.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for BoxSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"b: {}, b1: {}, h: {}, h1: {}",
&self.b, &self.b1, &self.h, &self.h1,
)
}
}
#[derive(Debug)]
pub struct ISec {
b: f32,
b1: f32,
b2: f32,
h: f32,
h1: f32,
h2: f32,
ws: Vec<u8>, //2b
}
impl HasWrite for ISec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.b.to_le_bytes());
out.extend(&self.b1.to_le_bytes());
out.extend(&self.b2.to_le_bytes());
out.extend(&self.h.to_le_bytes());
out.extend(&self.h1.to_le_bytes());
out.extend(&self.h2.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for ISec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"b: {}, b1: {}, b2: {}, h: {}, h1: {}, h2: {}",
&self.b, &self.b1, &self.b2, &self.h, &self.h1, &self.h2,
)
}
}
#[derive(Debug)]
pub struct ShelvesSec {
b: f32,
h: f32,
b1: f32,
h1: f32,
b2: f32,
h2: f32,
ws: Vec<u8>, //2b
}
impl HasWrite for ShelvesSec {
fn write(&self) -> Vec<u8> {
let mut out = vec![];
out.extend(&self.b.to_le_bytes());
out.extend(&self.h.to_le_bytes());
out.extend(&self.b1.to_le_bytes());
out.extend(&self.h1.to_le_bytes());
out.extend(&self.b2.to_le_bytes());
out.extend(&self.h2.to_le_bytes());
out.extend(&self.ws);
out
}
fn name(&self) -> &str {
""
}
}
impl fmt::Display for ShelvesSec {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"b: {}, h: {}, b1: {}, h1: {}, b2: {}, h2: {}",
&self.b, &self.h, &self.b1, &self.h1, &self.b2, &self.h2,
)
}
}
pub fn read_rectangle_sec(i: &[u8]) -> IResult<&[u8], RectangleSec> {
let (i, b) = le_f32(i)?;
let (i, h) = le_f32(i)?;
let (i, flag_f) = le_u8(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
RectangleSec {
b,
h,
flag_f,
ws: ws.to_vec(),
},
))
}
pub fn read_circle_sec(i: &[u8]) -> IResult<&[u8], CircleSec> {
let (i, d) = le_f32(i)?;
let (i, flag_f) = le_u8(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
CircleSec {
d,
flag_f,
ws: ws.to_vec(),
},
))
}
pub fn read_cross_sec(i: &[u8]) -> IResult<&[u8], CrossSec> {
let (i, b1) = le_f32(i)?;
let (i, b2) = le_f32(i)?;
let (i, b3) = le_f32(i)?;
let (i, h1) = le_f32(i)?;
let (i, h2) = le_f32(i)?;
let (i, h3) = le_f32(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
CrossSec {
b1,
b2,
b3,
h1,
h2,
h3,
ws: ws.to_vec(),
},
))
}
pub fn read_ring_sec(i: &[u8]) -> IResult<&[u8], RingSec> {
let (i, d) = le_f32(i)?;
let (i, t) = le_f32(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
RingSec {
d,
t,
ws: ws.to_vec(),
},
))
}
pub fn read_box_sec(i: &[u8]) -> IResult<&[u8], BoxSec> {
let (i, b) = le_f32(i)?;
let (i, b1) = le_f32(i)?;
let (i, h) = le_f32(i)?;
let (i, h1) = le_f32(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
BoxSec {
b,
b1,
h,
h1,
ws: ws.to_vec(),
},
))
}
pub fn read_bead_sec(i: &[u8]) -> IResult<&[u8], ISec> {
let (i, b) = le_f32(i)?;
let (i, b1) = le_f32(i)?;
let (i, b2) = le_f32(i)?;
let (i, h) = le_f32(i)?;
let (i, h1) = le_f32(i)?;
let (i, h2) = le_f32(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
ISec {
b,
b1,
b2,
h,
h1,
h2,
ws: ws.to_vec(),
},
))
}
pub fn read_shelves_sec(i: &[u8]) -> IResult<&[u8], ShelvesSec> {
let (i, b) = le_f32(i)?;
let (i, h) = le_f32(i)?;
let (i, b1) = le_f32(i)?;
let (i, h1) = le_f32(i)?;
let (i, b2) = le_f32(i)?;
let (i, h2) = le_f32(i)?;
let (i, ws) = take(2u8)(i)?;
Ok((
i,
ShelvesSec {
b,
h,
b1,
h1,
b2,
h2,
ws: ws.to_vec(),
},
))
}
pub fn read_sec(i: &[u8], type_sec: u8) -> IResult<&[u8], Sec> {
match type_sec {
1 => {
let (i, rectangle) = read_rectangle_sec(i)?;
Ok((i, Sec::Rectangle(rectangle)))
}
2 => {
let (i, circle) = read_circle_sec(i)?;
Ok((i, Sec::Circle(circle)))
}
3 => {
let (i, cross) = read_cross_sec(i)?;
Ok((i, Sec::Cross(cross)))
}
4 => {
let (i, ring) = read_ring_sec(i)?;
Ok((i, Sec::Ring(ring)))
}
5 => {
let (i, _box) = read_box_sec(i)?;
Ok((i, Sec::Box(_box)))
}
6 => {
let (i, isec) = read_bead_sec(i)?;
Ok((i, Sec::ISec(isec)))
}
7 => {
let (i, shelves) = read_shelves_sec(i)?;
Ok((i, Sec::Shelves(shelves)))
}
_ => panic!("type_sec error"),
}
}
|
fn main() {
proconio::input!{n:u64,r:u64};
println!("{}", if n >= 10 { r } else { r + 1000 - 100 * n })
}
|
use crate::ast;
use bitvec;
use serde::{Deserialize, Serialize};
type BitVec = bitvec::vec::BitVec<bitvec::order::Lsb0, u64>;
// TODO: Use entity-component system like the specs crate?
// TODO:
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
pub struct Module {
pub symbols: Vec<String>,
/// Bitvector of which symbols are names and not arguments
pub names: BitVec,
pub imports: Vec<String>,
pub strings: Vec<String>,
pub numbers: Vec<u64>,
pub declarations: Vec<Declaration>,
}
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug, Default)]
pub struct Declaration {
pub procedure: Vec<usize>, // Only symbols
pub call: Vec<Expression>,
pub closure: Vec<usize>, // TODO: BitVec
}
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug)]
pub enum Expression {
Symbol(usize),
Import(usize),
Literal(usize),
Number(usize),
}
impl Module {
fn symbol(&mut self, n: usize, s: String) -> usize {
if self.symbols.len() <= n {
self.symbols
.extend(std::iter::repeat(String::default()).take(1 + n - self.symbols.len()));
}
assert!(self.symbols.len() > n);
self.symbols[n] = s;
n
}
pub fn provided_mask(&self, decl: &Declaration) -> BitVec {
let mut mask = BitVec::repeat(false, self.symbols.len());
for i in &decl.procedure {
mask.set(*i, true);
}
mask
}
pub fn required_mask(&self, decl: &Declaration) -> BitVec {
let mut mask = BitVec::repeat(false, self.symbols.len());
for e in &decl.call {
if let Expression::Symbol(s) = e {
mask.set(*s, true);
}
}
mask
}
fn convert(&mut self, expr: ast::Expression) -> Expression {
use ast::Expression::*;
match expr {
Reference(Some(n), s) => Expression::Symbol(self.symbol(n, s)),
Reference(None, s) => {
Expression::Import(if let Some(i) = self.imports.iter().position(|e| e == &s) {
i
} else {
self.imports.push(s);
self.imports.len() - 1
})
}
Literal(s) => {
Expression::Literal(if let Some(i) = self.strings.iter().position(|e| e == &s) {
i
} else {
self.strings.push(s);
self.strings.len() - 1
})
}
Number(n) => {
Expression::Number(if let Some(i) = self.numbers.iter().position(|e| e == &n) {
i
} else {
self.numbers.push(n);
self.numbers.len() - 1
})
}
_ => panic!("Need to bind and digest sugar first."),
}
}
pub fn declaration<'a>(&'a self, name: usize) -> Option<&'a Declaration> {
self.declarations
.iter()
.find(|decl| decl.procedure[0] == name)
}
pub fn find_names(&mut self) {
self.names = BitVec::repeat(false, self.symbols.len());
for decl in &self.declarations {
self.names.set(decl.procedure[0], true);
}
}
fn closure_rec(&self, decl: &Declaration, provided: &BitVec) -> BitVec {
// TODO: Reformulate as a linear problem over GF(2)^{N x M} and
// solve using (sparse) matrices.
let context = self.provided_mask(decl) | provided.clone();
let required = self.required_mask(decl);
let mut closure = required & !context.clone();
let names = closure.clone() & self.names.clone();
// If a closure element is a name, it will be recursively replaced
// by the associated closure. But note that we still filter out
// procedure.
for name in (0..self.symbols.len()).filter(|i| names[*i]) {
closure.set(name, false);
closure |= self.closure_rec(self.declaration(name).unwrap(), &context);
}
// Can not have any names in the closure.
assert!((closure.clone() & self.names.clone()).not_any());
closure
}
pub fn compute_closures(&mut self) {
assert_eq!(self.names.len(), self.symbols.len());
let empty = BitVec::repeat(false, self.symbols.len());
let closures = self
.declarations
.iter()
.map(|decl| self.closure_rec(decl, &empty))
.collect::<Vec<_>>();
for (decl, closure) in self.declarations.iter_mut().zip(closures.into_iter()) {
decl.closure = (0..self.symbols.len())
.filter(|i| closure[*i])
.collect::<Vec<_>>();
}
}
}
impl From<&ast::Statement> for Module {
/// Requires the block to be desugared
fn from(block: &ast::Statement) -> Self {
let mut module = Module::default();
if let ast::Statement::Block(statements) = block {
module.declarations = statements
.iter()
.map(|statement| {
match statement {
ast::Statement::Closure(a, b) => {
Declaration {
procedure: a
.iter()
.map(|binder| {
module.symbol(
binder.0.expect("Must be bound"),
binder.1.clone(),
)
})
.collect::<Vec<_>>(),
call: b
.iter()
.map(|expr| module.convert(expr.clone()))
.collect::<Vec<_>>(),
closure: Vec::new(),
}
}
_ => panic!("Expected closure"),
}
})
.collect::<Vec<_>>();
} else {
panic!("Expected block")
}
module.find_names();
module.compute_closures();
module
}
}
|
//! An interface to read data from the systemโs power_supply class.
//! Uses the built-in legoev3-battery if none is specified.
use std::{fs, path::Path};
use crate::driver::DRIVER_PATH;
use crate::utils::OrErr;
use crate::{Attribute, Device, Driver, Ev3Error, Ev3Result};
/// An interface to read data from the systemโs power_supply class.
/// Uses the built-in legoev3-battery if none is specified.
#[derive(Debug, Clone, Device)]
pub struct PowerSupply {
driver: Driver,
}
impl PowerSupply {
/// Create a new instance of `PowerSupply`.
pub fn new() -> Ev3Result<PowerSupply> {
let paths = fs::read_dir(Path::new(DRIVER_PATH).join("power_supply"))?;
for path in paths {
let file_name = path?.file_name();
let name = file_name.to_str().or_err()?;
if name.contains("ev3-battery") {
return Ok(PowerSupply {
driver: Driver::new("power_supply", name),
});
}
}
Err(Ev3Error::NotConnected {
device: "power_supply".to_owned(),
port: None,
})
}
/// Returns the battery current in microamps
pub fn get_current_now(&self) -> Ev3Result<i32> {
self.get_attribute("current_now").get()
}
/// Always returns System.
pub fn get_scope(&self) -> Ev3Result<String> {
self.get_attribute("zscope").get()
}
/// Returns Unknown or Li-ion depending on if the rechargeable battery is present.
pub fn get_technology(&self) -> Ev3Result<String> {
self.get_attribute("technology").get()
}
/// Always returns Battery.
pub fn get_type(&self) -> Ev3Result<String> {
self.get_attribute("type").get()
}
/// Returns the nominal โfullโ battery voltage. The value returned depends on technology.
pub fn get_voltage_max_design(&self) -> Ev3Result<i32> {
self.get_attribute("voltage_max_design").get()
}
/// Returns the nominal โemptyโ battery voltage. The value returned depends on technology.
pub fn get_voltage_min_design(&self) -> Ev3Result<i32> {
self.get_attribute("voltage_min_design").get()
}
/// Returns the battery voltage in microvolts.
pub fn get_voltage_now(&self) -> Ev3Result<i32> {
self.get_attribute("voltage_now").get()
}
}
|
use std::{
future::Future,
path::{Path, PathBuf},
pin::Pin,
sync::{Arc, Mutex},
task::{Context, Poll, Waker},
};
#[derive(Default)]
struct ReaderState {
res: Option<std::io::Result<Vec<u8>>>,
waker: Option<Waker>,
}
struct Reader {
state: Arc<Mutex<ReaderState>>,
}
impl Reader {
fn new(path: &Path) -> Self {
let state: Arc<Mutex<ReaderState>> = Arc::new(Mutex::new(Default::default()));
{
let path = path.to_owned();
let state = state.clone();
std::thread::Builder::new()
.name("rfd_file_read".into())
.spawn(move || {
let res = std::fs::read(path);
let mut state = state.lock().unwrap();
state.res.replace(res);
if let Some(waker) = state.waker.take() {
waker.wake();
}
})
.unwrap();
}
Self { state }
}
}
impl Future for Reader {
type Output = Vec<u8>;
fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output> {
let mut state = self.state.lock().unwrap();
if state.res.is_some() {
let res = state.res.take().unwrap();
Poll::Ready(res.unwrap())
} else {
state.waker.replace(ctx.waker().clone());
Poll::Pending
}
}
}
/// FileHandle is a way of abstracting over a file returned by a dialog
pub struct FileHandle(PathBuf);
impl FileHandle {
/// On native platforms it wraps path.
///
/// On `WASM32` it wraps JS `File` object.
pub fn wrap(path_buf: PathBuf) -> Self {
Self(path_buf)
}
/// Get name of a file
pub fn file_name(&self) -> String {
self.0
.file_name()
.and_then(|f| f.to_str())
.map(|f| f.to_string())
.unwrap_or_default()
}
/// Gets path to a file.
///
/// Does not exist in `WASM32`
pub fn path(&self) -> &Path {
&self.0
}
/// Reads a file asynchronously.
///
/// On native platforms it spawns a `std::thread` in the background.
///
/// `This fn exists souly to keep native api in pair with async only web api.`
pub async fn read(&self) -> Vec<u8> {
Reader::new(&self.0).await
}
/// Unwraps a `FileHandle` and returns innet type.
///
/// It should be used, if user wants to handle file read themselves
///
/// On native platforms returns path.
///
/// On `WASM32` it returns JS `File` object.
///
/// #### Behind a `file-handle-inner` feature flag
#[cfg(feature = "file-handle-inner")]
pub fn inner(&self) -> &Path {
&self.0
}
}
impl std::fmt::Debug for FileHandle {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self.path())
}
}
impl From<PathBuf> for FileHandle {
fn from(path: PathBuf) -> Self {
Self(path)
}
}
|
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use nannou::prelude::*;
type Points = Vec<Point2<f32>>;
fn smooth(points: &Points) -> Points {
let last_index = points.len() - 1;
let num_line_segments = points.len() - 1;
// Each line segment creates two points.
let mut smoothed: Points = Vec::with_capacity(num_line_segments * 2);
for index in 0..last_index {
let point = points[index];
let next_point = points[index + 1];
let near = point * 0.75 + next_point * 0.25;
let far = point * 0.25 + next_point * 0.75;
smoothed.push(near);
smoothed.push(far);
}
smoothed
}
fn criterion_benchmark(c: &mut Criterion) {
let points: Points = (0..10_000)
.map(|_| pt2(random_f32(), random_f32()))
.collect();
c.bench_function("smooth", |b| b.iter(|| smooth(black_box(&points))));
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
|
use std::{
collections::{btree_map, BTreeMap, HashSet},
iter::{Iterator, Peekable},
};
use oasis_core_runtime::storage::mkvs;
use super::{NestedStore, Store};
/// An overlay store which keeps values locally until explicitly committed.
pub struct OverlayStore<S: Store> {
parent: S,
overlay: BTreeMap<Vec<u8>, Vec<u8>>,
dirty: HashSet<Vec<u8>>,
}
impl<S: Store> OverlayStore<S> {
/// Create a new overlay store.
pub fn new(parent: S) -> Self {
Self {
parent,
overlay: BTreeMap::new(),
dirty: HashSet::new(),
}
}
}
impl<S: Store> NestedStore for OverlayStore<S> {
type Inner = S;
fn commit(mut self) -> Self::Inner {
// Insert all items present in the overlay.
for (key, value) in self.overlay {
self.dirty.remove(&key);
self.parent.insert(&key, &value);
}
// Any remaining dirty items must have been removed.
for key in self.dirty {
self.parent.remove(&key);
}
self.parent
}
}
impl<S: Store> Store for OverlayStore<S> {
fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
// For dirty values, check the overlay.
if self.dirty.contains(key) {
return self.overlay.get(key).cloned();
}
// Otherwise fetch from parent store.
self.parent.get(key)
}
fn insert(&mut self, key: &[u8], value: &[u8]) {
self.overlay.insert(key.to_owned(), value.to_owned());
self.dirty.insert(key.to_owned());
}
fn remove(&mut self, key: &[u8]) {
// For dirty values, remove from the overlay.
if self.dirty.contains(key) {
self.overlay.remove(key);
return;
}
// Since we don't care about the previous value, we can just record an update.
self.dirty.insert(key.to_owned());
}
fn iter(&self) -> Box<dyn mkvs::Iterator + '_> {
Box::new(OverlayStoreIterator::new(self))
}
}
/// An iterator over the `OverlayStore`.
pub(crate) struct OverlayStoreIterator<'store, S: Store> {
store: &'store OverlayStore<S>,
parent: Box<dyn mkvs::Iterator + 'store>,
overlay: Peekable<btree_map::Range<'store, Vec<u8>, Vec<u8>>>,
overlay_valid: bool,
key: Option<Vec<u8>>,
value: Option<Vec<u8>>,
}
impl<'store, S: Store> OverlayStoreIterator<'store, S> {
fn new(store: &'store OverlayStore<S>) -> Self {
Self {
store,
parent: store.parent.iter(),
overlay: store.overlay.range(vec![]..).peekable(),
overlay_valid: true,
key: None,
value: None,
}
}
fn update_iterator_position(&mut self) {
// Skip over any dirty entries from the parent iterator.
loop {
if !self.parent.is_valid()
|| !self
.store
.dirty
.contains(self.parent.get_key().as_ref().expect("parent.is_valid"))
{
break;
}
self.parent.next();
}
let i_key = self.parent.get_key();
let o_item = self.overlay.peek();
self.overlay_valid = o_item.is_some();
if self.parent.is_valid()
&& (!self.overlay_valid
|| i_key.as_ref().expect("parent.is_valid") < o_item.expect("overlay_valid").0)
{
// Key of parent iterator is smaller than the key of the overlay iterator.
self.key = i_key.clone();
self.value = self.parent.get_value().clone();
} else if self.overlay_valid {
// Key of overlay iterator is smaller than or equal to the key of the parent iterator.
let (o_key, o_value) = o_item.expect("overlay_valid");
self.key = Some(o_key.to_vec());
self.value = Some(o_value.to_vec());
} else {
// Both iterators are invalid.
self.key = None;
self.value = None;
}
}
fn next(&mut self) {
if !self.overlay_valid
|| (self.parent.is_valid()
&& self.parent.get_key().as_ref().expect("parent.is_valid")
<= self.overlay.peek().expect("overlay_valid").0)
{
// Key of parent iterator is smaller or equal than the key of the overlay iterator.
self.parent.next();
} else {
// Key of parent iterator is greater than the key of the overlay iterator.
self.overlay.next();
}
self.update_iterator_position();
}
}
impl<'store, S: Store> Iterator for OverlayStoreIterator<'store, S> {
type Item = (Vec<u8>, Vec<u8>);
fn next(&mut self) -> Option<Self::Item> {
use mkvs::Iterator;
if !self.is_valid() {
return None;
}
let key = self.key.as_ref().expect("iterator is valid").clone();
let value = self.value.as_ref().expect("iterator is valid").clone();
OverlayStoreIterator::next(self);
Some((key, value))
}
}
impl<'store, S: Store> mkvs::Iterator for OverlayStoreIterator<'store, S> {
fn set_prefetch(&mut self, prefetch: usize) {
self.parent.set_prefetch(prefetch)
}
fn is_valid(&self) -> bool {
// If either iterator is valid, the merged iterator is valid.
self.parent.is_valid() || self.overlay_valid
}
fn error(&self) -> &Option<anyhow::Error> {
self.parent.error()
}
fn rewind(&mut self) {
self.seek(&[]);
}
fn seek(&mut self, key: &[u8]) {
self.parent.seek(key);
self.overlay = self.store.overlay.range(key.to_vec()..).peekable();
self.update_iterator_position();
}
fn get_key(&self) -> &Option<mkvs::Key> {
&self.key
}
fn get_value(&self) -> &Option<Vec<u8>> {
&self.value
}
fn next(&mut self) {
OverlayStoreIterator::next(self)
}
}
|
pub fn hello_world() {
println!("\n--- hello_world() ---");
println!("Hello, world!");
} |
use crate::apps::SubApp;
use clap::Clap;
use cli_table::{format::Justify, print_stdout, Cell, Style, Table};
use std::error::Error;
use electric_lib::usb::{HidDevice, HidManager};
#[derive(Clap, Debug)]
pub struct ShowUSBApp {
#[clap(short = 'w', long = "watch", about = "Continuously watch changes of USB device connectivity")]
pub watch_changes: bool,
}
impl SubApp for ShowUSBApp {
fn process(&mut self) -> Result<(), Box<dyn Error>> {
let man = HidManager::new();
let devices = man.get_usb_devices();
print_devices(&devices);
Ok(())
}
}
fn print_devices(devices: &Vec<HidDevice>) {
let table = devices
.iter()
.map(|d| {
vec![
d.path.to_owned().cell(),
d.product_id.cell(),
d.vendor_id.cell(),
d.dev_class.to_owned().cell(),
d.dev_man.to_owned().cell(),
d.product_str.to_owned().cell(),
d.serial_num_str.to_owned().cell(),
d.dev_inst.unwrap_or_default().cell(),
d.pdo_name.to_owned().cell(),
]
})
//.collect::<Vec<_>>()
.table()
.title(vec![
"Path".cell().bold(true),
"PID".cell().bold(true),
"VID".cell().bold(true),
"Class".cell().bold(true),
"Manufacturer".cell().bold(true),
"Product".cell().bold(true),
"Ser. #".cell().bold(true),
"Dev. Inst.".cell().bold(true),
"PDO Name".cell().bold(true),
])
.bold(true);
print_stdout(table).unwrap();
} |
extern crate memmap;
use std::fs::OpenOptions;
use memmap::MmapMut;
fn init_balancesheet() {
const PATH: &str = "BALANCE";
let file = OpenOptions::new().read(true).write(true).create(true).open(&PATH).unwrap();
// 25 million users 4 bytes per balance
file.set_len(25_000_000 * 4).unwrap();
let mut mmap = unsafe { MmapMut::map_mut(&file).unwrap() };
for i in 0..25_000_000 {
mmap[i * 4 + 0] = 5;
mmap[i * 4 + 1] = 0;
mmap[i * 4 + 2] = 0;
mmap[i * 4 + 3] = 0;
}
}
fn main() {
init_balancesheet();
}
|
use reqwest::Client;
use wiremock::matchers::any;
use wiremock::{Mock, MockServer, ResponseTemplate};
async fn test_body() {
// Arrange
let mock_server = MockServer::start().await;
let response = ResponseTemplate::new(200).set_delay(std::time::Duration::from_secs(60));
Mock::given(any())
.respond_with(response)
.mount(&mock_server)
.await;
// Act
let outcome = Client::builder()
.timeout(std::time::Duration::from_secs(1))
.build()
.unwrap()
.get(&mock_server.uri())
.send()
.await;
// Assert
assert!(outcome.is_err());
}
#[actix_rt::test]
async fn request_times_out_if_the_server_takes_too_long_with_actix() {
test_body().await
}
#[tokio::test]
async fn request_times_out_if_the_server_takes_too_long_with_tokio() {
test_body().await
}
|
use std::env::args;
use std::net::{SocketAddr, UdpSocket};
use std::str::FromStr;
fn main() {
let arguments: Vec<String> = args().collect();
let server = &arguments[1];
let client = &arguments[2];
let socket = UdpSocket::bind(server).unwrap();
let to = SocketAddr::from_str(client).unwrap();
let buf = "Some string";
socket.send_to(buf.as_ref(), &to).unwrap();
}
|
use header::Header;
use std::fmt;
use std::ops::{Index, IndexMut, Range};
#[derive(Debug)]
pub struct Cart {
pub mem: Vec<u8>,
pub headers: Vec<Header>,
}
impl Cart {
pub fn new(mem: Vec<u8>) -> Cart {
Cart {
mem: mem,
headers: vec![
Header::new("entry point", 0x100..0x104),
Header::new("logo", 0x104..0x134),
Header::with_format("title", 0x134..0x144, "string"),
Header::new("manufacturer", 0x13F..0x142),
Header::new("color game boy", 0x143..0x144),
Header::new("new licensee", 0x144..0x146),
Header::new("super game boy", 0x146..0x147),
Header::new("cart type", 0x147..0x148),
Header::new("rom size", 0x148..0x149),
Header::new("ram size", 0x149..0x14A),
Header::new("destination", 0x14A..0x14B),
Header::new("old licensee", 0x14B..0x14C),
Header::new("make rom version", 0x14C..0x14D),
Header::new("header checksum", 0x14D..0x14E),
Header::new("global checksum", 0x14E..0x150),
Header::new("short header", 0x134..0x14D),
Header::new("full header", 0x100..0x14F),
],
}
}
fn checksum(&self) -> u8 {
self.mem[0x134..0x14D].iter().fold(0, |a: u8, &b| a.wrapping_sub(b + 1))
}
fn global_checksum(&self) -> u16 {
let sum = self.mem.iter().fold(0, |a: u16, &b| a.wrapping_add(b as u16));
sum - self.mem[0x14D] as u16 - self.mem[0x14E] as u16
}
pub fn is_valid(&self) -> bool {
self.checksum() == self.mem[0x14D]
}
}
impl fmt::Display for Cart {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for header in &self.headers {
if header.format == "string" {
try!(writeln!(f,
"{}: {}",
header.name,
String::from_utf8_lossy(&self.mem[header.range.start..header.range
.end])));
} else {
try!(write!(f, "{}: [", header.name));
for byte in &self.mem[header.range.start..header.range.end - 1] {
try!(write!(f, "{:0>2X}, ", byte));
}
try!(writeln!(f, "{:0>2X}]", &self.mem[header.range.end]));
}
}
if self.is_valid() {
try!(writeln!(f, "checksum passed!"));
} else {
try!(writeln!(f, "checksum failed!"));
}
writeln!(f, "global checksum {:X}", self.global_checksum())
}
}
impl Index<u16> for Cart {
type Output = u8;
fn index(&self, index: u16) -> &u8 {
&self.mem[index as usize]
}
}
impl Index<usize> for Cart {
type Output = u8;
fn index(&self, index: usize) -> &u8 {
&self.mem[index]
}
}
impl IndexMut<u16> for Cart {
fn index_mut(&mut self, index: u16) -> &mut u8 {
&mut self.mem[index as usize]
}
}
impl IndexMut<usize> for Cart {
fn index_mut(&mut self, index: usize) -> &mut u8 {
&mut self.mem[index]
}
}
impl Index<Range<u16>> for Cart {
type Output = [u8];
fn index(&self, range: Range<u16>) -> &Self::Output {
let usize_range = (range.start as usize)..(range.end as usize);
&self[usize_range]
}
}
impl Index<Range<usize>> for Cart {
type Output = [u8];
fn index(&self, range: Range<usize>) -> &Self::Output {
&self.mem[range]
}
}
|
// Day 12
use std::cmp::{max, min};
use std::error::Error;
use std::fs;
use std::process;
fn main() {
let input_filename = "input.txt";
if let Err(e) = run(input_filename) {
println!("Application error: {}", e);
process::exit(1);
}
}
fn run(filename: &str) -> Result<(), Box<dyn Error>> {
// Read the input file: this is the Intcode program
let contents = fs::read_to_string(filename)?;
let mut positions: Vec<Vec<i32>> = contents
.trim()
.split("\n")
.map(|x| parse_input_string(x))
.collect();
/* 4 planets have the initial positions as given, and velocity 0.
For each time step, update the velocity by applying gravity
The update the position by applying velocity
*/
let mut velocities = vec![vec![0; 3]; 4];
let mut t = 1;
// Part 2: Determine the number of steps that must occur before all of the moons' positions and velocities exactly match a previous point in time.
// The x, y and z coordinates are independent of each other, so the length of the cycle is the least common multiple of the lengths of the x, y and z cycle
let initial_x_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[0]).collect();
let initial_y_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[1]).collect();
let initial_z_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[2]).collect();
let initial_x_velocities: Vec<i32> = vec![0; 4];
let initial_y_velocities: Vec<i32> = vec![0; 4];
let initial_z_velocities: Vec<i32> = vec![0; 4];
let mut periods_found = [false, false, false];
let mut peroids = [0, 0, 0];
loop {
update_velocities(&mut velocities, &mut positions);
update_positions(&mut velocities, &mut positions);
// println! {"Step number {}", t};
// for i in 0..velocities.len() {
// println!(
// "Position: {:?} Velocity: {:?}",
// positions[i], velocities[i]
// );
// }
let potential_energies = get_potential_energy(&positions);
let kinetic_energies = get_kinetic_energy(&velocities);
let mut total_energy = 0;
for i in 0..potential_energies.len() {
let e_p = potential_energies[i];
let e_k = kinetic_energies[i];
total_energy += e_p * e_k;
}
if t == 1000 {
println!("Total energy after 1000 steps: {}", total_energy);
println!("");
}
let x_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[0]).collect();
let y_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[1]).collect();
let z_positions: Vec<i32> = positions.clone().into_iter().map(|d| d[2]).collect();
let x_velocities: Vec<i32> = velocities.clone().into_iter().map(|d| d[0]).collect();
let y_velocities: Vec<i32> = velocities.clone().into_iter().map(|d| d[1]).collect();
let z_velocities: Vec<i32> = velocities.clone().into_iter().map(|d| d[2]).collect();
if !periods_found[0]
&& x_positions == initial_x_positions
&& x_velocities == initial_x_velocities
{
println!("x-Period: {}", t);
periods_found[0] = true;
peroids[0] = t;
}
if !periods_found[1]
&& y_positions == initial_y_positions
&& y_velocities == initial_y_velocities
{
println!("y-Period: {}", t);
periods_found[1] = true;
peroids[1] = t;
}
if !periods_found[2]
&& z_positions == initial_z_positions
&& z_velocities == initial_z_velocities
{
println!("z-Period: {}", t);
periods_found[2] = true;
peroids[2] = t;
}
if periods_found == [true, true, true] {
println!(
"Steps taken before positions and velocities back to initial state: {}",
lcm(lcm(peroids[0], peroids[1]), peroids[2]) as i64
);
break;
}
t += 1;
}
Ok(())
}
fn gcd(a: usize, b: usize) -> usize {
match ((a, b), (a & 1, b & 1)) {
((x, y), _) if x == y => y,
((0, x), _) | ((x, 0), _) => x,
((x, y), (0, 1)) | ((y, x), (1, 0)) => gcd(x >> 1, y),
((x, y), (0, 0)) => gcd(x >> 1, y >> 1) << 1,
((x, y), (1, 1)) => {
let (x, y) = (min(x, y), max(x, y));
gcd((y - x) >> 1, x)
}
_ => unreachable!(),
}
}
fn lcm(a: usize, b: usize) -> usize {
a * b / gcd(a, b)
}
fn get_potential_energy(p: &Vec<Vec<i32>>) -> Vec<i32> {
// The potential energy is the sum of the absolute x,y,z values
let mut potential_energy: Vec<i32> = Vec::new();
for position in p {
let mut e_p = 0;
for axis in 0..3 {
e_p += position[axis].abs();
}
potential_energy.push(e_p);
}
potential_energy
}
fn get_kinetic_energy(v: &Vec<Vec<i32>>) -> Vec<i32> {
// The kinetic energy is the sum of the absolute x,y,z values
let mut kinetic_energy: Vec<i32> = Vec::new();
for velocity in v {
let mut e_k = 0;
for axis in 0..3 {
e_k += velocity[axis].abs();
}
kinetic_energy.push(e_k)
}
kinetic_energy
}
fn update_positions(v: &mut Vec<Vec<i32>>, p: &mut Vec<Vec<i32>>) -> () {
// Add the velocity of each moon to its own position
for moon_index in 0..v.len() {
for axis in 0..3 {
p[moon_index][axis] += v[moon_index][axis];
}
}
}
fn update_velocities(v: &mut Vec<Vec<i32>>, p: &mut Vec<Vec<i32>>) -> () {
// On each axis, the velocity of each moons change by exactly +1 or -1 to pull
// the moons together, for every pair of moons
for moon_index_i in 0..v.len() {
let moon_position_i = &p[moon_index_i];
for moon_index_j in 0..moon_index_i {
let moon_position_j = &p[moon_index_j];
for axis in 0..3 {
if moon_position_i[axis] < moon_position_j[axis] {
v[moon_index_i][axis] += 1;
v[moon_index_j][axis] -= 1;
} else if moon_position_i[axis] > moon_position_j[axis] {
v[moon_index_i][axis] -= 1;
v[moon_index_j][axis] += 1;
}
}
}
}
}
fn parse_input_string(input_string: &str) -> Vec<i32> {
// input takes the form <x=-6, y=-5, z=-8>
// remove the first and last characters (< and >)
let output: Vec<i32> = input_string
.split(",")
.map(|d| d.parse().unwrap())
.collect();
output
}
|
use serde::{Deserialize, Serialize};
use crate::api::message::amount::*;
// use serde::ser::{Serializer, SerializeStruct};
use crate::api::utils::tx_flags::*;
use std::error::Error;
use std::fmt;
#[derive(Serialize, Deserialize, Debug)]
pub struct SetBrokerageTxJson {
#[serde(rename="Flags")]
pub flags: u32,
#[serde(rename="Fee")]
pub fee: u64,
#[serde(rename="TransactionType")]
pub transaction_type: String,
#[serde(rename="Account")]
pub manage_account: String,
#[serde(rename="OfferFeeRateNum")]
pub offer_feerate_num: u64,
#[serde(rename="OfferFeeRateDen")]
pub offer_feerate_den: u64,
#[serde(rename="FeeAccountID")]
pub fee_account: String,
#[serde(rename="Amount")]
#[serde(deserialize_with = "string_or_struct")]
pub amount: Amount,
#[serde(rename="sequence")]
pub sequence: u32,
}
impl SetBrokerageTxJson {
pub fn new(account: String, fee_account: String, sequence: u32, offer_feerate_num: u64, offer_feerate_den: u64, amount: Amount) -> Self {
let flag = Flags::Other;
SetBrokerageTxJson {
flags: flag.get(),
fee : 10000,
transaction_type: "Brokerage".to_string(),
manage_account: account,
sequence: sequence,
offer_feerate_num: offer_feerate_num,
offer_feerate_den: offer_feerate_den,
fee_account: fee_account,
amount: amount,
}
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SetBrokerageTx {
#[serde(rename="command")]
pub command: String,
#[serde(rename="secret")]
pub secret: String,
#[serde(rename="tx_json")]
pub tx_json: SetBrokerageTxJson,
}
impl SetBrokerageTx {
pub fn new(secret: String, tx_json: SetBrokerageTxJson) -> Box<SetBrokerageTx> {
Box::new( SetBrokerageTx {
command: "submit".to_string(),
secret : secret,
tx_json: tx_json,
})
}
pub fn to_string(&self) -> Result<String, serde_json::error::Error> {
let j = serde_json::to_string(&self)?;
Ok(j)
}
}
#[derive(Serialize, Deserialize, Debug)]
pub struct SetBrokerageTxJsonResponse {
#[serde(rename="Account")]
pub account: String,
#[serde(rename="Amount")]
pub amount: Amount,
#[serde(rename="Fee")]
pub fee: String,
#[serde(rename="FeeAccountID")]
pub fee_account: String,
#[serde(rename="Flags")]
pub flags: u32,
#[serde(rename="OfferFeeRateDen")]
pub den: String,
#[serde(rename="OfferFeeRateNum")]
pub num: String,
#[serde(rename="Sequence")]
pub sequence: u64,
#[serde(rename="SigningPubKey")]
pub signing_pub_key: String,
#[serde(rename="Timestamp")]
pub timestamp: Option<u64>,
#[serde(rename="TransactionType")]
pub transaction_type: String,
#[serde(rename="TxnSignature")]
pub txn_signature: String,
#[serde(rename="hash")]
pub hash: String,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct FeeRateResponse {
#[serde(rename="engine_result")]
pub engine_result: String,
#[serde(rename="engine_result_code")]
pub engine_result_code: i32,
#[serde(rename="engine_result_message")]
pub engine_result_message: String,
#[serde(rename="tx_blob")]
pub tx_blob: String,
#[serde(rename="tx_json")]
pub tx_json: Option<SetBrokerageTxJsonResponse>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct SetBrokerageSideKick {
pub error : String,
pub error_code : i32,
pub error_message : String,
pub id : u32,
pub request : SetBrokerageTx,
pub status : String,
#[serde(rename="type")]
pub rtype : String,
}
impl fmt::Display for SetBrokerageSideKick {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "SetBrokerageSideKick is here!")
}
}
impl Error for SetBrokerageSideKick {
fn description(&self) -> &str {
"I'm SetBrokerageSideKick side kick"
}
}
|
//! Developer extensions for basic-http-server
use super::{Config, HtmlCfg};
use super::{Error, Result};
use comrak::ComrakOptions;
use futures::{future, future::Either, Future, Stream};
use http::{Request, Response, StatusCode};
use hyper::{header, Body};
use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
use std::ffi::OsStr;
use std::fmt::Write;
use std::io;
use std::path::{Path, PathBuf};
use tokio::fs::{self, File};
use tokio_fs::DirEntry;
pub fn serve(
config: Config,
req: Request<Body>,
resp: super::Result<Response<Body>>,
) -> Box<dyn Future<Item = Response<Body>, Error = Error> + Send + 'static> {
trace!("checking extensions");
if !config.use_extensions {
return Box::new(future::result(resp));
}
let path = super::local_path_for_request(&req.uri(), &config.root_dir);
if path.is_none() {
return Box::new(future::result(resp));
}
let path = path.unwrap();
let file_ext = path.extension().and_then(OsStr::to_str).unwrap_or("");
if file_ext == "md" {
trace!("using markdown extension");
return Box::new(md_path_to_html(&path));
}
if let Err(e) = resp {
match e {
Error::Io(e) => {
if e.kind() == io::ErrorKind::NotFound {
Box::new(maybe_list_dir(&config.root_dir, &path).and_then(
move |list_dir_resp| {
trace!("using directory list extension");
if let Some(f) = list_dir_resp {
Either::A(future::ok(f))
} else {
Either::B(future::err(Error::from(e)))
}
},
))
} else {
return Box::new(future::err(Error::from(e)));
}
}
_ => {
return Box::new(future::err(e));
}
}
} else {
Box::new(future::result(resp))
}
}
fn md_path_to_html(path: &Path) -> impl Future<Item = Response<Body>, Error = Error> {
File::open(path.to_owned()).then(move |open_result| match open_result {
Ok(file) => Either::A(md_file_to_html(file)),
Err(e) => Either::B(future::err(Error::Io(e))),
})
}
fn md_file_to_html(file: File) -> impl Future<Item = Response<Body>, Error = Error> {
let mut options = ComrakOptions::default();
// be like GitHub
options.ext_autolink = true;
options.ext_header_ids = None;
options.ext_table = true;
options.ext_strikethrough = true;
options.ext_tagfilter = true;
options.ext_tasklist = true;
options.github_pre_lang = true;
options.ext_header_ids = Some("user-content-".to_string());
super::read_file(file)
.and_then(|s| String::from_utf8(s).map_err(|_| Error::MarkdownUtf8))
.and_then(move |s: String| {
let html = comrak::markdown_to_html(&s, &options);
let cfg = HtmlCfg {
title: String::new(),
body: html,
};
super::render_html(cfg)
})
.and_then(move |html| {
Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_LENGTH, html.len() as u64)
.header(header::CONTENT_TYPE, mime::TEXT_HTML.as_ref())
.body(Body::from(html))
.map_err(Error::from)
})
}
fn maybe_list_dir(
root_dir: &Path,
path: &Path,
) -> impl Future<Item = Option<Response<Body>>, Error = Error> {
let root_dir = root_dir.to_owned();
let path = path.to_owned();
fs::metadata(path.clone())
.map_err(Error::from)
.and_then(move |m| {
if m.is_dir() {
Either::A(list_dir(&root_dir, &path))
} else {
Either::B(future::ok(None))
}
})
.map_err(Error::from)
}
fn list_dir(
root_dir: &Path,
path: &Path,
) -> impl Future<Item = Option<Response<Body>>, Error = Error> {
let root_dir = root_dir.to_owned();
let up_dir = path.join("..");
fs::read_dir(path.to_owned())
.map_err(Error::from)
.and_then(move |read_dir| {
let root_dir = root_dir.to_owned();
read_dir
.collect()
.map_err(Error::from)
.and_then(move |dents| {
let paths = dents.iter().map(DirEntry::path);
let paths = Some(up_dir).into_iter().chain(paths);
let paths: Vec<_> = paths.collect();
make_dir_list_body(&root_dir, &paths).map_err(Error::from)
})
.and_then(|html| super::html_str_to_response(html, StatusCode::OK).map(Some))
})
}
fn make_dir_list_body(root_dir: &Path, paths: &[PathBuf]) -> Result<String> {
let mut buf = String::new();
writeln!(buf, "<div>").map_err(Error::WriteInDirList)?;
let dot_dot = OsStr::new("..");
for path in paths {
let full_url = path
.strip_prefix(root_dir)
.map_err(Error::StripPrefixInDirList)?;
let maybe_dot_dot = || {
if path.ends_with("..") {
Some(dot_dot)
} else {
None
}
};
if let Some(file_name) = path.file_name().or_else(maybe_dot_dot) {
if let Some(file_name) = file_name.to_str() {
if let Some(full_url) = full_url.to_str() {
// %-encode filenames
// https://url.spec.whatwg.org/#fragment-percent-encode-set
const FRAGMENT_SET: &AsciiSet = &CONTROLS.add(b' ').add(b'"').add(b'<').add(b'>').add(b'`');
const PATH_SET: &AsciiSet = &FRAGMENT_SET.add(b'#').add(b'?').add(b'{').add(b'}');
let full_url = utf8_percent_encode(full_url, &PATH_SET);
// TODO: Make this a relative URL
writeln!(
buf,
"<div><a href='/{}'>{}</a></div>",
full_url,
file_name
)
.map_err(Error::WriteInDirList)?;
} else {
warn!("non-unicode url: {}", full_url.to_string_lossy());
}
} else {
warn!("non-unicode path: {}", file_name.to_string_lossy());
}
} else {
warn!("path without file name: {}", path.display());
}
}
writeln!(buf, "</div>").map_err(Error::WriteInDirList)?;
let cfg = HtmlCfg {
title: String::new(),
body: buf,
};
super::render_html(cfg)
}
|
///
///
///
use std;
use gtk;
pub trait ComponentStoreTrait {
fn add_component(&mut self, name: String, component: Box<gtk::WidgetTrait>) -> ();
fn remove_component(&mut self, name: &String) -> ();
fn get_component(&self, name: &String) -> Option<&Box<gtk::WidgetTrait>>;
}
|
use super::*;
mod with_atom_destination;
mod with_local_pid_destination;
#[test]
fn without_atom_or_pid_destination_errors_badarg() {
run!(
|arc_process| {
(
Just(arc_process.clone()),
milliseconds(),
strategy::term::is_not_send_after_destination(arc_process.clone()),
strategy::term(arc_process.clone()),
)
},
|(arc_process, milliseconds, destination, message)| {
let time = arc_process.integer(milliseconds);
let options = options(&arc_process);
prop_assert_badarg!(
result(arc_process.clone(), time, destination, message, options),
format!(
"destination ({}) is neither a registered name (atom) nor a local pid",
destination
)
);
Ok(())
},
);
}
|
use std::fs;
use std::io::prelude::*;
use std::net::TcpListener;
use std::net::TcpStream;
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
type Counter = std::sync::atomic::AtomicUsize;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
let counter = Arc::new(Counter::new(0));
for stream in listener.incoming() {
let stream = stream.unwrap();
let counter = Arc::clone(&counter);
std::thread::spawn(move || {
handle_connection(stream, counter);
});
}
println!("Hello, world!");
}
fn handle_connection(mut stream: TcpStream, counter: Arc<Counter>) {
let mut buffer = [0; 2048];
let buffer_size = stream.read(&mut buffer).unwrap();
let request = String::from_utf8_lossy(&buffer[..buffer_size]);
println!("Request: {}", request);
let (status_line, filename) = if request.starts_with("GET / HTTP") {
("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
} else if request.starts_with("GET /sleep HTTP") {
thread::sleep(Duration::from_secs(6));
("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let contents = contents.replace(
"${counter}",
format!("{}", counter.load(Ordering::SeqCst)).as_str(),
);
let response = format!("{}{}", status_line, contents);
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
counter.fetch_add(1, Ordering::SeqCst);
}
|
extern crate rustc_serialize;
extern crate walkdir;
extern crate pulldown_cmark;
extern crate mustache;
extern crate yaml_rust;
extern crate core;
extern crate frontmatter;
pub mod builders {
use walkdir::DirEntry;
use std::path::Path;
use yaml_rust::Yaml;
fn is_markdown(entry: &DirEntry) -> bool {
entry.file_name()
.to_str()
.map(|s| s.ends_with(".md"))
.unwrap_or(false)
}
fn is_special(entry: &DirEntry) -> bool {
entry.file_name()
.to_str()
.map(|s| s.starts_with("_"))
.unwrap_or(false)
}
fn is_git(entry: &DirEntry) -> bool {
entry.file_name()
.to_str()
.map(|s| s.starts_with(".git"))
.unwrap_or(false)
}
pub fn build_all(directory: &Path, config: &Yaml) -> Result<(), &'static str> {
// get list of all files down tree from current directory
markdown::build(directory, config);
direct_copy::build(directory, config);
Ok(())
}
pub mod markdown {
use walkdir::WalkDir;
use std::fs::{File, DirBuilder};
use std::io::{Read};
use std::path::{Path, PathBuf};
use pulldown_cmark;
use mustache;
use yaml_rust::Yaml;
use builders;
use frontmatter;
pub fn build(directory: &Path, config: &Yaml) {
let templates_dir = config["templates_dir"].as_str().unwrap_or("_templates");
let template_name = config["template_name"].as_str().unwrap_or("default");
let mut template_path = PathBuf::from(directory);
template_path.push(templates_dir);
template_path.push(template_name);
template_path.push("page.mustache");
let mut file = File::open(&template_path).expect("couldn't open template file");
let mut contents = String::new();
file.read_to_string(&mut contents).expect("couldn't read template file");
let default_template = mustache::compile_str(&contents);
let files = WalkDir::new(directory)
.into_iter()
.filter_map(|e| e.ok())
.filter(|e| !builders::is_git(&e))
.filter(|e| !builders::is_special(&e))
.filter(|e| builders::is_markdown(&e));
for entry in files {
// load file contents
let path = entry.path();
let mut file = File::open(&path).expect("couldn't open file");
let mut contents = String::new();
file.read_to_string(&mut contents).expect("couldn't read file");
// parse frontmatter
let (_matter_maybe, content_start) = frontmatter::parse_and_find_content(&contents).expect("couldn't parse frontmatter");
// convert markdown to html
let mut html = String::with_capacity(content_start.len() * 3/2);
let parsed = pulldown_cmark::Parser::new_ext(&content_start, pulldown_cmark::Options::empty());
pulldown_cmark::html::push_html(&mut html, parsed);
// wrap post body with html page template
let data_builder = mustache::MapBuilder::new()
.insert_str("body", &html);
let out_path_prefix = "./_site/";
let mut out_path = PathBuf::from(out_path_prefix);
out_path.push(path);
out_path.set_extension("html");
// ensure dir exists
DirBuilder::new()
.recursive(true)
.create(out_path.parent().unwrap()).unwrap();
let mut out_file = File::create(&out_path).expect("couldn't create out file");
default_template.render_data(&mut out_file,&data_builder.build());
}
}
}
pub mod direct_copy {
use walkdir::WalkDir;
use std::fs;
use std::fs::DirBuilder;
use std::path::{Path, PathBuf};
use yaml_rust::Yaml;
pub fn build(directory: &Path, config: &Yaml) {
let output_dir = config["output_dir"].as_str().unwrap_or("_site");
let templates_dir = config["templates_dir"].as_str().unwrap_or("_templates");
let template_name = config["template_name"].as_str().unwrap_or("default");
let mut statics_directory = PathBuf::from(directory);
statics_directory.push(templates_dir);
statics_directory.push(template_name);
statics_directory.push("static");
let files = WalkDir::new(statics_directory.clone())
.into_iter()
.filter_map(|e| e.ok())
.filter(|e| e.file_type().is_file());
for entry in files {
// load file contents
let in_path = entry.path();
let rel_path = iter_after(in_path.components(), statics_directory.components())
.map(|c| c.as_path()).expect("static file not in statics_directory");
let mut out_path = PathBuf::from(directory);
out_path.push(output_dir);
out_path.push(rel_path);
// ensure dir exists
DirBuilder::new()
.recursive(true)
.create(out_path.parent().unwrap()).expect("couldn't create directory");
fs::copy(in_path, out_path).expect("couldn't copy static file");
}
}
// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`
// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving
// `iter` after having exhausted `prefix`.
fn iter_after<A, I, J>(mut iter: I, mut prefix: J) -> Option<I>
where I: Iterator<Item = A> + Clone,
J: Iterator<Item = A>,
A: PartialEq
{
loop {
let mut iter_next = iter.clone();
match (iter_next.next(), prefix.next()) {
(Some(x), Some(y)) => {
if x != y {
return None;
}
}
(Some(_), None) => return Some(iter),
(None, None) => return Some(iter),
(None, Some(_)) => return None,
}
iter = iter_next;
}
}
}
}
pub mod config {
use std::fs::File;
use std::io;
use std::io::Read;
use std::path::Path;
use yaml_rust::{Yaml, YamlLoader};
pub fn read(folder: &Path) -> Result<Yaml, io::Error> {
let mut file_path = folder.to_path_buf();
file_path.push("Virgil.yaml");
let mut file = try!(File::open(file_path));
let mut contents = String::new();
try!(file.read_to_string(&mut contents));
let mut documents = YamlLoader::load_from_str(&contents)
.unwrap_or(vec![Yaml::Null]);
Ok(documents.pop().unwrap_or(Yaml::Null))
}
}
pub mod init {
use walkdir::WalkDir;
use std::fs::File;
use std::path::Path;
pub fn init_folder(folder: &Path) -> Result<(), &'static str> {
if !folder.is_dir() {
return Err("must init existing directory");
}
let files = WalkDir::new(folder)
.into_iter().peekable();
if files.count() > 1 {
return Err("directory not empty, can't initialize site");
}
File::create("Virgil.yaml").expect("couldn't create blank config");
Ok(())
}
}
|
// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![crate_name = "qwop"]
/// (writen on a spider's web) Some Macro
#[macro_export]
macro_rules! some_macro {
() => {
println!("this is some macro, for sure");
};
}
/// Some other macro, to fill space.
#[macro_export]
macro_rules! other_macro {
() => {
println!("this is some other macro, whatev");
};
}
/// This macro is so cool, it's Super.
#[macro_export]
macro_rules! super_macro {
() => {
println!("is it a bird? a plane? no, it's Super Macro!");
};
}
|
use crate::math::{Color, Point};
use super::{SolidColor, Texture};
pub struct CheckerTexture {
even: Box<dyn Texture>,
odd: Box<dyn Texture>,
}
impl CheckerTexture {
pub fn new(even: Box<dyn Texture>, odd: Box<dyn Texture>) -> Self {
CheckerTexture {
even,
odd,
}
}
pub fn new_from_colors(c1: Color, c2: Color) -> Self {
CheckerTexture::new(
Box::new(SolidColor::new(c1)),
Box::new(SolidColor::new(c2))
)
}
}
impl Texture for CheckerTexture {
fn value(&self, u: f64, v: f64, p: Point) -> Color {
let sines = (10.0 * p.x).sin() * (10.0 * p.y).sin() * (10.0 * p.z).sin();
if sines < 0.0 {
self.odd.value(u, v, p)
} else {
self.even.value(u, v, p)
}
}
} |
use std::io::{self, BufRead};
fn main() {
let stdin = io::stdin();
let mut iterator = stdin.lock().lines();
let mut cases: i32 = iterator.next().unwrap().unwrap().parse().unwrap();
while cases > 0 {
cases -= 1;
let mut nums = iterator.next().unwrap().unwrap();
let values: Vec<i32> = nums
.as_mut_str()
.split_whitespace()
.map(|s| s.parse().unwrap())
.collect();
println!("{}", values[0] + values[1]);
}
}
|
use arrow::record_batch::RecordBatch;
use clap::ValueEnum;
use futures::TryStreamExt;
use influxdb_iox_client::format::influxql::{write_columnar, Options};
use influxdb_iox_client::{connection::Connection, flight, format::QueryOutputFormat};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum Error {
#[error("Error formatting: {0}")]
Formatting(#[from] influxdb_iox_client::format::Error),
#[error("Error querying: {0}")]
Query(#[from] influxdb_iox_client::flight::Error),
#[error("Error formatting InfluxQL: {0}")]
InfluxQlFormatting(#[from] influxdb_iox_client::format::influxql::Error),
}
pub type Result<T, E = Error> = std::result::Result<T, E>;
#[derive(clap::ValueEnum, Clone, Debug, PartialEq)]
#[clap(rename_all = "lower")]
enum QueryLanguage {
/// Interpret the query as DataFusion SQL
Sql,
/// Interpret the query as InfluxQL
InfluxQL,
}
/// Query the data with SQL
#[derive(Debug, clap::Parser)]
pub struct Config {
/// The IOx namespace to query
#[clap(action)]
namespace: String,
/// The query to run, in SQL format
#[clap(action)]
query: String,
/// Output format of the query results
#[clap(short, long, action)]
#[clap(value_enum, default_value_t = OutputFormat::Pretty)]
format: OutputFormat,
/// Query type used
#[clap(short = 'l', long = "lang", default_value = "sql")]
query_lang: QueryLanguage,
}
#[derive(Debug, Clone, ValueEnum)]
enum OutputFormat {
/// Output the most appropriate format for the query language
Pretty,
/// Output the query results using the Arrow JSON formatter
Json,
/// Output the query results using the Arrow CSV formatter
Csv,
/// Output the query results using the Arrow pretty formatter
Table,
}
impl From<OutputFormat> for QueryOutputFormat {
fn from(value: OutputFormat) -> Self {
match value {
OutputFormat::Pretty | OutputFormat::Table => Self::Pretty,
OutputFormat::Json => Self::Json,
OutputFormat::Csv => Self::Csv,
}
}
}
pub async fn command(connection: Connection, config: Config) -> Result<()> {
let mut client = flight::Client::new(connection);
let Config {
namespace,
format,
query,
query_lang,
} = config;
let mut query_results = match query_lang {
QueryLanguage::Sql => client.sql(namespace, query).await,
QueryLanguage::InfluxQL => client.influxql(namespace, query).await,
}?;
// It might be nice to do some sort of streaming write
// rather than buffering the whole thing.
let mut batches: Vec<_> = (&mut query_results).try_collect().await?;
// read schema AFTER collection, otherwise the stream does not have the schema data yet
let schema = query_results
.inner()
.schema()
.cloned()
.ok_or(influxdb_iox_client::flight::Error::NoSchema)?;
// preserve schema so we print table headers even for empty results
batches.push(RecordBatch::new_empty(schema));
match (query_lang, &format) {
(QueryLanguage::InfluxQL, OutputFormat::Pretty) => {
write_columnar(std::io::stdout(), &batches, Options::default())?
}
_ => {
let format: QueryOutputFormat = format.into();
let formatted_result = format.format(&batches)?;
println!("{formatted_result}");
}
}
Ok(())
}
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use carnelian::{make_message, set_node_color, Color, Point, Rect, ViewAssistantContext};
use failure::Error;
use fidl_fuchsia_ui_input::{PointerEvent, PointerEventPhase};
use fuchsia_scenic::{EntityNode, Rectangle, SessionPtr, ShapeNode};
use crate::{message::VoilaMessage, TOGGLE_Z};
pub struct Toggle {
background_node: ShapeNode,
container: EntityNode,
pub bounds: Rect,
bg_color_on: Color,
bg_color_off: Color,
is_on: bool,
}
impl Toggle {
pub fn new(session: &SessionPtr) -> Result<Toggle, Error> {
let toggle = Toggle {
background_node: ShapeNode::new(session.clone()),
container: EntityNode::new(session.clone()),
bounds: Rect::zero(),
bg_color_on: Color::from_hash_code("#00C0DE")?,
bg_color_off: Color::from_hash_code("#404040")?,
is_on: false,
};
toggle.container.add_child(&toggle.background_node);
Ok(toggle)
}
pub fn toggle(&mut self) {
self.is_on = !self.is_on;
}
pub fn update(&mut self, bounds: &Rect, session: &SessionPtr) -> Result<(), Error> {
self.container.set_translation(
bounds.origin.x + (bounds.size.width / 2.0),
bounds.origin.y + (bounds.size.height / 2.0),
TOGGLE_Z,
);
let color = if self.is_on { self.bg_color_on } else { self.bg_color_off };
set_node_color(session, &self.background_node, &color);
// Record bounds for hit testing.
self.bounds = bounds.clone();
self.background_node.set_shape(&Rectangle::new(
session.clone(),
self.bounds.size.width,
self.bounds.size.height,
));
Ok(())
}
pub fn node(&self) -> &EntityNode {
&self.container
}
pub fn handle_pointer_event(
&mut self,
context: &mut ViewAssistantContext,
pointer_event: &PointerEvent,
key: u32,
) {
match pointer_event.phase {
PointerEventPhase::Down => {}
PointerEventPhase::Add => {}
PointerEventPhase::Hover => {}
PointerEventPhase::Move => {}
PointerEventPhase::Up => {
if self.bounds.contains(&Point::new(pointer_event.x, pointer_event.y)) {
context
.queue_message(make_message(VoilaMessage::ReplicaConnectivityToggled(key)));
}
}
PointerEventPhase::Remove => {}
PointerEventPhase::Cancel => {}
}
}
}
|
// Copyright 2021 Datafuse Labs.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use common_exception::Result;
use common_meta_types::MatchSeq;
use common_meta_types::NodeInfo;
#[async_trait::async_trait]
pub trait ClusterApi: Sync + Send {
// Add a new node info to /tenant/cluster_id/node-name.
async fn add_node(&self, node: NodeInfo) -> Result<u64>;
// Get the tenant's cluster all nodes.
async fn get_nodes(&self) -> Result<Vec<NodeInfo>>;
// Drop the tenant's cluster one node by node.id.
async fn drop_node(&self, node_id: String, seq: MatchSeq) -> Result<()>;
// Keep the tenant's cluster node alive.
async fn heartbeat(&self, node: &NodeInfo, seq: MatchSeq) -> Result<u64>;
async fn get_local_addr(&self) -> Result<Option<String>>;
}
|
pub struct SimpleLinkedList<T> {
head: Option<Box<Node<T>>>,
len: usize,
}
struct Node<T> {
data: T,
next: Option<Box<Node<T>>>,
}
impl<T> SimpleLinkedList<T> {
pub fn new() -> Self {
SimpleLinkedList { head: None, len: 0 }
}
pub fn len(&self) -> usize {
self.len
}
pub fn push(&mut self, element: T) {
let node = Box::new(Node::new(element, self.head.take()));
self.head = Some(node);
self.len += 1;
}
pub fn pop(&mut self) -> Option<T> {
match self.len {
0 => None,
_ => {
self.len -= 1;
self.head.take().map(|node| {
let node = *node;
self.head = node.next;
node.data
})
}
}
}
pub fn peek(&self) -> Option<&T> {
self.head.as_ref().map(|node| &node.data)
}
}
impl<T: Clone> SimpleLinkedList<T> {
pub fn rev(&self) -> SimpleLinkedList<T> {
let mut rev_list = SimpleLinkedList::new();
let mut next = self.head.as_ref().map(|node| &**node);
while let Some(node) = next {
rev_list.push(node.data.clone());
next = node.next.as_ref().map(|node| &**node);
}
rev_list
}
}
impl<'a, T: Clone> From<&'a [T]> for SimpleLinkedList<T> {
fn from(item: &[T]) -> Self {
let mut list = SimpleLinkedList::new();
for i in item {
list.push(i.clone());
}
list
}
}
impl<T> Into<Vec<T>> for SimpleLinkedList<T> {
let l: int32 = 32;
fn into(mut self) -> Vec<T> {
let mut vec = Vec::new();
while let Some(data) = self.pop() {
vec.push(data);
}
vec.reverse();
vec
}
}
impl<T> Node<T> {
pub fn new(element: T, next: Option<Box<Node<T>>>) -> Self {
Node {
data: element,
next,
}
}
}
|
use crate::{
event::merge_state::LogEventMergeState,
event::{self, Event, LogEvent, Value},
shutdown::ShutdownSignal,
topology::config::{DataType, GlobalOptions, SourceConfig, SourceDescription},
};
use bollard::{
container::{InspectContainerOptions, ListContainersOptions, LogOutput, LogsOptions},
errors::{Error as DockerError, ErrorKind as DockerErrorKind},
service::{ContainerInspectResponse, SystemEventsResponse},
system::EventsOptions,
Docker,
};
use bytes05::{Buf, Bytes};
use chrono::{DateTime, FixedOffset, Local, NaiveTime, Utc, MAX_DATE};
use futures::{
compat::{Future01CompatExt, Sink01CompatExt},
future,
sink::SinkExt,
FutureExt, Stream, StreamExt, TryFutureExt,
};
use futures01::sync::mpsc as mpsc01;
use lazy_static::lazy_static;
use serde::{Deserialize, Serialize};
use std::pin::Pin;
use std::sync::Arc;
use std::{collections::HashMap, env};
use string_cache::DefaultAtom as Atom;
use tokio::sync::mpsc;
use tracing::field;
/// The begining of image names of vector docker images packaged by vector.
const VECTOR_IMAGE_NAME: &str = "timberio/vector";
lazy_static! {
static ref STDERR: Bytes = "stderr".into();
static ref STDOUT: Bytes = "stdout".into();
static ref IMAGE: Atom = Atom::from("image");
static ref CREATED_AT: Atom = Atom::from("container_created_at");
static ref NAME: Atom = Atom::from("container_name");
static ref STREAM: Atom = Atom::from("stream");
static ref CONTAINER: Atom = Atom::from("container_id");
}
#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(deny_unknown_fields, default)]
pub struct DockerConfig {
include_containers: Option<Vec<String>>, // Starts with actually, not include
include_labels: Option<Vec<String>>,
include_images: Option<Vec<String>>,
partial_event_marker_field: Option<Atom>,
auto_partial_merge: bool,
}
impl Default for DockerConfig {
fn default() -> Self {
Self {
include_containers: None,
include_labels: None,
include_images: None,
partial_event_marker_field: Some(event::PARTIAL.clone()),
auto_partial_merge: true,
}
}
}
impl DockerConfig {
fn container_name_included<'a>(
&self,
id: &str,
names: impl IntoIterator<Item = &'a str>,
) -> bool {
if let Some(include_containers) = &self.include_containers {
let id_flag = include_containers
.iter()
.any(|include| id.starts_with(include));
let name_flag = names.into_iter().any(|name| {
include_containers
.iter()
.any(|include| name.starts_with(include))
});
id_flag || name_flag
} else {
true
}
}
fn with_empty_partial_event_marker_field_as_none(mut self) -> Self {
if let Some(val) = &self.partial_event_marker_field {
if val.is_empty() {
self.partial_event_marker_field = None;
}
}
self
}
}
inventory::submit! {
SourceDescription::new::<DockerConfig>("docker")
}
#[typetag::serde(name = "docker")]
impl SourceConfig for DockerConfig {
fn build(
&self,
_name: &str,
_globals: &GlobalOptions,
shutdown: ShutdownSignal,
out: mpsc01::Sender<Event>,
) -> crate::Result<super::Source> {
let source = DockerSource::new(
self.clone().with_empty_partial_event_marker_field_as_none(),
out,
shutdown.clone(),
)?;
// Capture currently running containers, and do main future(run)
let fut = async move {
match source.handle_running_containers().await {
Ok(source) => source.run().await,
Err(error) => {
error!(message = "Listing currently running containers, failed", %error);
}
}
};
// Once this ShutdownSignal resolves it will drop DockerSource and by extension it's ShutdownSignal.
Ok(Box::new(
async move {
Ok(tokio::select! {
_ = fut => {}
_ = shutdown.compat() => {}
})
}
.boxed()
.compat(),
))
}
fn output_type(&self) -> DataType {
DataType::Log
}
fn source_type(&self) -> &'static str {
"docker"
}
}
struct DockerSourceCore {
config: DockerConfig,
docker: Docker,
/// Only logs created at, or after this moment are logged.
now_timestamp: DateTime<Utc>,
}
impl DockerSourceCore {
fn new(config: DockerConfig) -> crate::Result<Self> {
// ?NOTE: Constructs a new Docker instance for a docker host listening at url specified by an env var DOCKER_HOST.
// ? Otherwise connects to unix socket which requires sudo privileges, or docker group membership.
let docker = docker()?;
// Only log events created at-or-after this moment are logged.
let now = Local::now();
info!(
message = "Capturing logs from now on",
now = %now.to_rfc3339()
);
Ok(DockerSourceCore {
config,
docker,
now_timestamp: now.into(),
})
}
/// Returns event stream coming from docker.
fn docker_event_stream(
&self,
) -> impl Stream<Item = Result<SystemEventsResponse, DockerError>> + Send {
let mut filters = HashMap::new();
// event | emmited on commands
// -------+-------------------
// start | docker start, docker run, restart policy, docker restart
// unpause | docker unpause
// die | docker restart, docker stop, docker kill, process exited, oom
// pause | docker pause
filters.insert(
"event".to_owned(),
vec![
"start".to_owned(),
"unpause".to_owned(),
"die".to_owned(),
"pause".to_owned(),
],
);
filters.insert("type".to_owned(), vec!["container".to_owned()]);
// Apply include filters
if let Some(include_labels) = &self.config.include_labels {
filters.insert("label".to_owned(), include_labels.clone());
}
if let Some(include_images) = &self.config.include_images {
filters.insert("image".to_owned(), include_images.clone());
}
self.docker.events(Some(EventsOptions {
since: self.now_timestamp,
// Handler in Docker API:
// https://github.com/moby/moby/blob/c833222d54c00d64a0fc44c561a5973ecd414053/api/server/router/system/system_routes.go#L155
until: MAX_DATE.and_time(NaiveTime::from_hms(0, 0, 0)).unwrap(),
filters,
}))
}
}
/// Main future which listens for events coming from docker, and maintains
/// a fan of event_stream futures.
/// Where each event_stream corresponds to a runing container marked with ContainerLogInfo.
/// While running, event_stream streams Events to out channel.
/// Once a log stream has ended, it sends ContainerLogInfo back to main.
///
/// Future channel Future channel
/// |<---- event_stream ---->out
/// main <----|<---- event_stream ---->out
/// | ... ...out
///
struct DockerSource {
esb: EventStreamBuilder,
/// event stream from docker
events: Pin<Box<dyn Stream<Item = Result<SystemEventsResponse, DockerError>> + Send>>,
/// mappings of seen container_id to their data
containers: HashMap<ContainerId, ContainerState>,
///receives ContainerLogInfo comming from event stream futures
main_recv: mpsc::UnboundedReceiver<ContainerLogInfo>,
/// It may contain shortened container id.
hostname: Option<String>,
/// True if self needs to be excluded
exclude_self: bool,
}
impl DockerSource {
fn new(
config: DockerConfig,
out: mpsc01::Sender<Event>,
shutdown: ShutdownSignal,
) -> crate::Result<DockerSource> {
// Find out it's own container id, if it's inside a docker container.
// Since docker doesn't readily provide such information,
// various approches need to be made. As such the solution is not
// exact, but probable.
// This is to be used only if source is in state of catching everything.
// Or in other words, if includes are used then this is not necessary.
let exclude_self = config
.include_containers
.clone()
.unwrap_or_default()
.is_empty()
&& config.include_labels.clone().unwrap_or_default().is_empty();
// Only logs created at, or after this moment are logged.
let core = DockerSourceCore::new(config)?;
// main event stream, with whom only newly started/restarted containers will be loged.
let events = core.docker_event_stream();
info!(message = "Listening docker events");
// Channel of communication between main future and event_stream futures
let (main_send, main_recv) = mpsc::unbounded_channel::<ContainerLogInfo>();
// Starting with logs from now.
// TODO: Is this exception acceptable?
// Only somewhat exception to this is case where:
// t0 -- outside: container running
// t1 -- now_timestamp
// t2 -- outside: container stoped
// t3 -- list_containers
// In that case, logs between [t1,t2] will be pulled to vector only on next start/unpause of that container.
let esb = EventStreamBuilder {
core: Arc::new(core),
out,
main_send,
shutdown,
};
Ok(DockerSource {
esb,
events: Box::pin(events),
containers: HashMap::new(),
main_recv,
hostname: env::var("HOSTNAME").ok(),
exclude_self,
})
}
/// Future that captures currently running containers, and starts event streams for them.
async fn handle_running_containers(mut self) -> crate::Result<Self> {
let mut filters = HashMap::new();
// Apply include filters
if let Some(include_labels) = &self.esb.core.config.include_labels {
filters.insert("label".to_owned(), include_labels.clone());
}
if let Some(include_images) = &self.esb.core.config.include_images {
filters.insert("ancestor".to_owned(), include_images.clone());
}
self.esb
.core
.docker
.list_containers(Some(ListContainersOptions {
all: false, // only running containers
filters,
..Default::default()
}))
.await?
.into_iter()
.for_each(|container| {
let id = container.id.unwrap();
let names = container.names.unwrap();
let image = container.image.unwrap();
trace!(
message = "Found already running container",
id = field::display(&id),
names = field::debug(&names)
);
if !self.exclude_vector(id.as_str(), image.as_str()) {
return;
}
if !self.esb.core.config.container_name_included(
id.as_str(),
names.iter().map(|s| {
// In this case bollard / shiplift gives names with starting '/' so it needs to be removed.
let s = s.as_str();
if s.starts_with('/') {
s.split_at('/'.len_utf8()).1
} else {
s
}
}),
) {
trace!(message = "Container excluded", id = field::display(&id));
return;
}
let id = ContainerId::new(id);
self.containers.insert(id.clone(), self.esb.start(id));
});
Ok(self)
}
async fn run(mut self) {
loop {
tokio::select! {
value = self.main_recv.next() => {
match value {
Some(info) => {
let state = self
.containers
.get_mut(&info.id)
.expect("Every ContainerLogInfo has it's ContainerState");
if state.return_info(info) {
self.esb.restart(state);
}
}
None => {
error!(message = "docker source main stream has ended unexpectedly");
info!(message = "Shuting down docker source");
return;
}
};
}
value = self.events.next() => {
match value {
Some(Ok(mut event)) => {
let action = event.action.unwrap();
let actor = event.actor.take().unwrap();
let id = actor.id.unwrap();
let attributes = actor.attributes.unwrap();
trace!(
message = "docker event",
id = field::display(&id),
action = field::display(&action),
timestamp = field::display(event.time.unwrap()),
attributes = field::debug(&attributes),
);
let id = ContainerId::new(id);
// Update container status
match action.as_str() {
"die" | "pause" => {
if let Some(state) = self.containers.get_mut(&id) {
state.stoped();
}
}
"start" | "unpause" => {
if let Some(state) = self.containers.get_mut(&id) {
state.running();
self.esb.restart(state);
} else {
let include_name =
self.esb.core.config.container_name_included(
id.as_str(),
attributes.get("name").map(|s| s.as_str()),
);
let self_check = self.exclude_vector(
id.as_str(),
attributes.get("image").map(|s| s.as_str()),
);
if include_name && self_check {
self.containers.insert(id.clone(), self.esb.start(id));
}
}
}
_ => {},
};
}
Some(Err(error)) => error!(source = "docker events", %error),
None => {
// TODO: this could be fixed, but should be tryed with some timeoff and exponential backoff
error!(message = "docker event stream has ended unexpectedly");
info!(message = "Shuting down docker source");
return;
}
};
}
};
}
}
/// True if container with the given id and image must be excluded from logging,
/// because it's a vector instance, probably this one.
fn exclude_vector<'a>(&self, id: &str, image: impl Into<Option<&'a str>>) -> bool {
if self.exclude_self {
let hostname_hint = self
.hostname
.as_ref()
.map(|maybe_short_id| id.starts_with(maybe_short_id))
.unwrap_or(false);
let image_hint = image
.into()
.map(|image| image.starts_with(VECTOR_IMAGE_NAME))
.unwrap_or(false);
if hostname_hint || image_hint {
// This container is probably itself.
info!(message = "Detected self container", id);
return false;
}
}
true
}
}
/// Used to construct and start event stream futures
#[derive(Clone)]
struct EventStreamBuilder {
core: Arc<DockerSourceCore>,
/// Event stream futures send events through this
out: mpsc01::Sender<Event>,
/// End through which event stream futures send ContainerLogInfo to main future
main_send: mpsc::UnboundedSender<ContainerLogInfo>,
/// Self and event streams will end on this.
shutdown: ShutdownSignal,
}
impl EventStreamBuilder {
/// Constructs and runs event stream until shutdown.
fn start(&self, id: ContainerId) -> ContainerState {
let this = self.clone();
tokio::spawn(async move {
Arc::clone(&this.core)
.docker
.inspect_container(id.clone().as_str(), None::<InspectContainerOptions>)
.map_err(|error| error!(message = "Fetching container details failed", %error))
.and_then(|details| async move {
ContainerMetadata::from_details(details)
.map_err(|error| error!(message = "Metadata extraction failed", %error))
})
.and_then(|metadata| async move {
let info = ContainerLogInfo::new(id, metadata, this.core.now_timestamp);
this.start_event_stream(info).await;
Ok::<(), ()>(())
})
.await
});
ContainerState::new()
}
/// If info is present, restarts event stream which will run until shutdown.
fn restart(&self, container: &mut ContainerState) {
if let Some(info) = container.take_info() {
let this = self.clone();
tokio::spawn(async move { this.start_event_stream(info).await });
}
}
async fn start_event_stream(&self, mut info: ContainerLogInfo) {
// Establish connection
let options = Some(LogsOptions {
follow: true,
stdout: true,
stderr: true,
since: info.log_since(),
timestamps: true,
..Default::default()
});
let stream = self.core.docker.logs(info.id.as_str(), options);
info!(
message = "Started listening logs on docker container",
id = field::display(info.id.as_str())
);
// Create event streamer
let main_send = self.main_send.clone();
let partial_event_marker_field = self.core.config.partial_event_marker_field.clone();
let auto_partial_merge = self.core.config.auto_partial_merge;
let mut partial_event_merge_state = None;
stream
.map(|value| {
match value {
Ok(message) => Ok(info.new_event(
message,
partial_event_marker_field.clone(),
auto_partial_merge,
&mut partial_event_merge_state,
)),
Err(error) => {
// On any error, restart connection
match error.kind() {
DockerErrorKind::DockerResponseServerError { status_code, .. }
if *status_code == http::StatusCode::NOT_IMPLEMENTED =>
{
error!(
r#"docker engine is not using either `jsonfile` or `journald`
logging driver. Please enable one of these logging drivers
to get logs from the docker daemon."#
)
}
_ => error!(message = "docker API container logging error", %error),
};
Err(())
}
}
})
.take_while(|v| future::ready(v.is_ok()))
.filter_map(|v| future::ready(v.transpose()))
.take_until(self.shutdown.clone().compat())
.forward(self.out.clone().sink_compat().sink_map_err(|_| ()))
.map(|_| {})
.await;
// End of stream
info!(
message = "Stoped listening logs on docker container",
id = field::display(info.id.as_str())
);
if let Err(error) = main_send.send(info) {
error!(message = "Unable to return ContainerLogInfo to main", %error);
}
}
}
/// Container ID as assigned by Docker.
/// Is actually a string.
#[derive(Hash, Clone, Eq, PartialEq, Ord, PartialOrd)]
struct ContainerId(Bytes);
impl ContainerId {
fn new(id: String) -> Self {
ContainerId(id.into())
}
fn as_str(&self) -> &str {
std::str::from_utf8(&self.0).expect("Container Id Bytes aren't String")
}
}
/// Kept by main to keep track of container state
struct ContainerState {
/// None if there is a event_stream of this container.
info: Option<ContainerLogInfo>,
/// True if Container is currently running
running: bool,
/// Of running
generation: u64,
}
impl ContainerState {
/// It's ContainerLogInfo pair must be created exactly once.
fn new() -> Self {
ContainerState {
info: None,
running: true,
generation: 0,
}
}
fn running(&mut self) {
self.running = true;
self.generation += 1;
}
fn stoped(&mut self) {
self.running = false;
}
/// True if it needs to be restarted.
#[must_use]
fn return_info(&mut self, info: ContainerLogInfo) -> bool {
debug_assert!(self.info.is_none());
// Generation is the only one strictly necessary,
// but with v.running, restarting event_stream is automtically done.
let restart = self.running || info.generation < self.generation;
self.info = Some(info);
restart
}
fn take_info(&mut self) -> Option<ContainerLogInfo> {
self.info.take().map(|mut info| {
// Update info
info.generation = self.generation;
info
})
}
}
/// Exchanged between main future and event_stream futures
struct ContainerLogInfo {
/// Container docker ID
id: ContainerId,
/// Timestamp of event which created this struct
created: DateTime<Utc>,
/// Timestamp of last log message with it's generation
last_log: Option<(DateTime<FixedOffset>, u64)>,
/// generation of ContainerState at event_stream creation
generation: u64,
metadata: ContainerMetadata,
}
impl ContainerLogInfo {
/// Container docker ID
/// Unix timestamp of event which created this struct
fn new(id: ContainerId, metadata: ContainerMetadata, created: DateTime<Utc>) -> Self {
ContainerLogInfo {
id,
created,
last_log: None,
generation: 0,
metadata,
}
}
/// Only logs after or equal to this point need to be fetched
fn log_since(&self) -> i64 {
self.last_log
.as_ref()
.map(|&(ref d, _)| d.timestamp())
.unwrap_or_else(|| self.created.timestamp())
- 1
}
/// Expects timestamp at the begining of message.
/// Expects messages to be ordered by timestamps.
fn new_event(
&mut self,
log_output: LogOutput,
partial_event_marker_field: Option<Atom>,
auto_partial_merge: bool,
partial_event_merge_state: &mut Option<LogEventMergeState>,
) -> Option<Event> {
let (stream, mut bytes_message) = match log_output {
LogOutput::StdErr { message } => (STDERR.clone(), message),
LogOutput::StdOut { message } => (STDOUT.clone(), message),
_ => return None,
};
let message = String::from_utf8_lossy(&bytes_message);
let mut splitter = message.splitn(2, char::is_whitespace);
let timestamp_str = splitter.next()?;
let timestamp = match DateTime::parse_from_rfc3339(timestamp_str) {
Ok(timestamp) => {
// Timestamp check
match self.last_log.as_ref() {
// Recieved log has not already been processed
Some(&(ref last, gen))
if *last < timestamp || (*last == timestamp && gen == self.generation) =>
{
// noop
}
// Recieved log is not from before of creation
None if self.created <= timestamp.with_timezone(&Utc) => (),
_ => {
trace!(
message = "Recieved older log",
timestamp = %timestamp_str
);
return None;
}
}
self.last_log = Some((timestamp, self.generation));
let log = splitter.next()?;
let remove_len = message.len() - log.len();
bytes_message.advance(remove_len);
// Provide the timestamp.
Some(timestamp.with_timezone(&Utc))
}
Err(error) => {
// Recieved bad timestamp, if any at all.
error!(message="Didn't recieve rfc3339 timestamp from docker",%error);
// So continue normally but without a timestamp.
None
}
};
// Message is actually one line from stderr or stdout, and they are
// delimited with newline, so that newline needs to be removed.
// If there's no newline, the event is considered partial, and will
// either be merged within the docker source, or marked accordingly
// before sending out, depending on the configuration.
let is_partial = if bytes_message
.last()
.map(|&b| b as char == '\n')
.unwrap_or(false)
{
bytes_message.truncate(bytes_message.len() - 1);
false
} else {
true
};
// Prepare the log event.
let mut log_event = {
let mut log_event = LogEvent::default();
// Source type
log_event.insert(event::log_schema().source_type_key(), "docker");
// The log message.
log_event.insert(event::log_schema().message_key().clone(), bytes_message);
// Stream we got the message from.
log_event.insert(STREAM.clone(), stream);
// Timestamp of the event.
if let Some(timestamp) = timestamp {
log_event.insert(event::log_schema().timestamp_key().clone(), timestamp);
}
// Container ID.
log_event.insert(CONTAINER.clone(), self.id.0.clone());
// Labels.
for (key, value) in self.metadata.labels.iter() {
log_event.insert(key.clone(), value.clone());
}
// Container name.
log_event.insert(NAME.clone(), self.metadata.name.clone());
// Container image.
log_event.insert(IMAGE.clone(), self.metadata.image.clone());
// Timestamp of the container creation.
log_event.insert(CREATED_AT.clone(), self.metadata.created_at);
// Return the resulting log event.
log_event
};
// If automatic partial event merging is requested - perform the
// merging.
// Otherwise mark partial events and return all the events with no
// merging.
let log_event = if auto_partial_merge {
// Partial event events merging logic.
// If event is partial, stash it and return `None`.
if is_partial {
// If we already have a partial event merge state, the current
// message has to be merged into that existing state.
// Otherwise, create a new partial event merge state with the
// current message being the initial one.
if let Some(partial_event_merge_state) = partial_event_merge_state {
partial_event_merge_state.merge_in_next_event(
log_event,
&[event::log_schema().message_key().clone()],
);
} else {
*partial_event_merge_state = Some(LogEventMergeState::new(log_event));
};
return None;
};
// This is not a parial event. If we have a partial event merge
// state from before, the current event must be a final event, that
// would give us a merged event we can return.
// Otherwise it's just a regular event that we return as-is.
match partial_event_merge_state.take() {
Some(partial_event_merge_state) => partial_event_merge_state
.merge_in_final_event(log_event, &[event::log_schema().message_key().clone()]),
None => log_event,
}
} else {
// If the event is partial, just set the partial event marker field.
if is_partial {
// Only add partial event marker field if it's requested.
if let Some(partial_event_marker_field) = partial_event_marker_field {
log_event.insert(partial_event_marker_field, true);
}
}
// Return the log event as is, partial or not. No merging here.
log_event
};
// Partial or not partial - we return the event we got here, because all
// other cases were handeled earlier.
let event = Event::Log(log_event);
trace!(message = "Received one event.", ?event);
Some(event)
}
}
struct ContainerMetadata {
/// label.key -> String
labels: Vec<(Atom, Value)>,
/// name -> String
name: Value,
/// image -> String
image: Value,
/// created_at
created_at: DateTime<Utc>,
}
impl ContainerMetadata {
fn from_details(details: ContainerInspectResponse) -> crate::Result<Self> {
let config = details.config.unwrap();
let name = details.name.unwrap();
let created = details.created.unwrap();
let labels = config
.labels
.as_ref()
.map(|map| {
map.iter()
.map(|(key, value)| (("label.".to_owned() + key).into(), value.as_str().into()))
.collect()
})
.unwrap_or_default();
Ok(ContainerMetadata {
labels,
name: name.as_str().trim_start_matches('/').into(),
image: config.image.unwrap().as_str().into(),
created_at: DateTime::parse_from_rfc3339(created.as_str())?.with_timezone(&Utc),
})
}
}
fn docker() -> Result<Docker, DockerError> {
let scheme = env::var("DOCKER_HOST").ok().and_then(|host| {
let uri = host.parse::<hyper::Uri>().expect("invalid url");
uri.into_parts().scheme
});
match scheme.as_ref().map(|s| s.as_str()) {
Some("http") => Docker::connect_with_http_defaults(),
Some("https") => Docker::connect_with_tls_defaults(),
_ => Docker::connect_with_local_defaults(),
}
}
#[cfg(all(test, feature = "docker-integration-tests"))]
mod tests {
use super::*;
use crate::runtime::Runtime;
use crate::test_util::{collect_n, runtime, trace_init};
use bollard::{
container::{
Config as ContainerConfig, CreateContainerOptions, KillContainerOptions,
RemoveContainerOptions, StartContainerOptions, WaitContainerOptions,
},
image::{CreateImageOptions, CreateImageResults, ListImagesOptions},
};
use futures::{compat::Future01CompatExt, stream::TryStreamExt};
use futures01::{Async, Stream as Stream01};
/// None if docker is not present on the system
fn source_with<'a, L: Into<Option<&'a str>>>(
names: &[&str],
label: L,
rt: &mut Runtime,
) -> mpsc01::Receiver<Event> {
source_with_config(
DockerConfig {
include_containers: Some(names.iter().map(|&s| s.to_owned()).collect()),
include_labels: Some(label.into().map(|l| vec![l.to_owned()]).unwrap_or_default()),
..DockerConfig::default()
},
rt,
)
}
/// None if docker is not present on the system
fn source_with_config(config: DockerConfig, rt: &mut Runtime) -> mpsc01::Receiver<Event> {
// trace_init();
let (sender, recv) = mpsc01::channel(100);
rt.spawn(
config
.build(
"default",
&GlobalOptions::default(),
ShutdownSignal::noop(),
sender,
)
.unwrap(),
);
recv
}
/// Users should ensure to remove container before exiting.
async fn log_container(name: &str, label: Option<&str>, log: &str, docker: &Docker) -> String {
cmd_container(name, label, vec!["echo", log], docker).await
}
/// Users should ensure to remove container before exiting.
/// Will resend message every so often.
async fn eternal_container(
name: &str,
label: Option<&str>,
log: &str,
docker: &Docker,
) -> String {
cmd_container(
name,
label,
vec![
"sh",
"-c",
format!("echo before; i=0; while [ $i -le 50 ]; do sleep 0.1; echo {}; i=$((i+1)); done", log).as_str(),
],
docker,
).await
}
/// Users should ensure to remove container before exiting.
async fn cmd_container(
name: &str,
label: Option<&str>,
cmd: Vec<&str>,
docker: &Docker,
) -> String {
if let Some(id) = cmd_container_for_real(name, label, cmd, docker).await {
id
} else {
// Maybe a before created container is present
info!(
message = "Assums that named container remained from previous tests",
name = name
);
name.to_owned()
}
}
/// Users should ensure to remove container before exiting.
async fn cmd_container_for_real(
name: &str,
label: Option<&str>,
cmd: Vec<&str>,
docker: &Docker,
) -> Option<String> {
pull_busybox(docker).await;
trace!("Creating container");
let options = Some(CreateContainerOptions { name });
let config = ContainerConfig {
image: Some("busybox"),
cmd: Some(cmd),
labels: label.map(|label| vec![(label, "")].into_iter().collect()),
..Default::default()
};
let container = docker.create_container(options, config).await;
container.ok().map(|c| c.id)
}
/// Polling busybox image
async fn pull_busybox(docker: &Docker) {
let mut filters = HashMap::new();
filters.insert("reference", vec!["busybox:latest"]);
let options = Some(ListImagesOptions {
filters,
..Default::default()
});
let images = docker.list_images(options).await.unwrap();
if images.is_empty() {
// If `busybox:latest` not found, pull it
let options = Some(CreateImageOptions {
from_image: "busybox",
tag: "latest",
..Default::default()
});
docker
.create_image(options, None, None)
.for_each(|item| async move {
match item.unwrap() {
err @ CreateImageResults::CreateImageError { .. } => panic!("{:?}", err),
_ => {}
}
})
.await
}
}
/// Returns once container has started
async fn container_start(id: &str, docker: &Docker) -> Result<(), bollard::errors::Error> {
trace!("Starting container");
let options = None::<StartContainerOptions<&str>>;
docker.start_container(id, options).await
}
/// Returns once container is done running
async fn container_wait(id: &str, docker: &Docker) -> Result<(), bollard::errors::Error> {
trace!("Waiting container");
docker
.wait_container(id, None::<WaitContainerOptions<&str>>)
.try_for_each(|exit| async move {
info!("Container exited with status code: {}", exit.status_code);
Ok(())
})
.await
}
/// Returns once container is killed
async fn container_kill(id: &str, docker: &Docker) -> Result<(), bollard::errors::Error> {
trace!("Waiting container");
docker
.kill_container(id, None::<KillContainerOptions<&str>>)
.await
}
/// Returns once container is done running
async fn container_run(id: &str, docker: &Docker) -> Result<(), bollard::errors::Error> {
container_start(id, docker).await?;
container_wait(id, docker).await
}
async fn container_remove(id: &str, docker: &Docker) {
trace!("Removing container");
// Don't panick, as this is unreleated to test, and there possibly other containers that need to be removed
let _ = docker
.remove_container(id, None::<RemoveContainerOptions>)
.await
.map_err(|e| error!(%e));
}
/// Returns once it's certain that log has been made
/// Expects that this is the only one with a container
async fn container_log_n(
n: usize,
name: &str,
label: Option<&str>,
log: &str,
docker: &Docker,
) -> String {
let id = log_container(name, label, log, docker).await;
for _ in 0..n {
if let Err(error) = container_run(&id, docker).await {
container_remove(&id, docker).await;
panic!("Container failed to start with error: {:?}", error);
}
}
id
}
/// Once function returns, the container has entered into running state.
/// Container must be killed before removed.
fn running_container(
name: &'static str,
label: Option<&'static str>,
log: &'static str,
docker: &Docker,
rt: &mut Runtime,
) -> String {
let out = source_with(&[name], None, rt);
let docker = docker.clone();
rt.block_on_std(async move {
let id = eternal_container(name, label, log, &docker).await;
if let Err(error) = container_start(&id, &docker).await {
container_remove(&id, &docker).await;
panic!("Container start failed with error: {:?}", error);
}
// Wait for before message
let events = collect_n(out, 1).compat().await.ok().unwrap();
assert_eq!(
events[0].as_log()[&event::log_schema().message_key()],
"before".into()
);
id
})
}
async fn is_empty<T>(mut rx: mpsc01::Receiver<T>) -> Result<bool, ()> {
futures01::future::poll_fn(move || Ok(Async::Ready(rx.poll()?.is_not_ready())))
.compat()
.await
}
#[test]
fn newly_started() {
trace_init();
let message = "9";
let name = "vector_test_newly_started";
let label = "vector_test_label_newly_started";
let mut rt = runtime();
let out = source_with(&[name], None, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id = container_log_n(1, name, Some(label), message, &docker).await;
let events = collect_n(out, 1).compat().await.ok().unwrap();
container_remove(&id, &docker).await;
let log = events[0].as_log();
assert_eq!(log[&event::log_schema().message_key()], message.into());
assert_eq!(log[&super::CONTAINER], id.into());
assert!(log.get(&super::CREATED_AT).is_some());
assert_eq!(log[&super::IMAGE], "busybox".into());
assert!(log.get(&format!("label.{}", label).into()).is_some());
assert_eq!(events[0].as_log()[&super::NAME], name.into());
assert_eq!(
events[0].as_log()[event::log_schema().source_type_key()],
"docker".into()
);
});
}
#[test]
fn restart() {
trace_init();
let message = "10";
let name = "vector_test_restart";
let mut rt = runtime();
let out = source_with(&[name], None, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id = container_log_n(2, name, None, message, &docker).await;
let events = collect_n(out, 2).compat().await.ok().unwrap();
container_remove(&id, &docker).await;
assert_eq!(
events[0].as_log()[&event::log_schema().message_key()],
message.into()
);
assert_eq!(
events[1].as_log()[&event::log_schema().message_key()],
message.into()
);
});
}
#[test]
fn include_containers() {
trace_init();
let message = "11";
let name0 = "vector_test_include_container_0";
let name1 = "vector_test_include_container_1";
let mut rt = runtime();
let out = source_with(&[name1], None, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id0 = container_log_n(1, name0, None, "13", &docker).await;
let id1 = container_log_n(1, name1, None, message, &docker).await;
let events = collect_n(out, 1).compat().await.ok().unwrap();
container_remove(&id0, &docker).await;
container_remove(&id1, &docker).await;
assert_eq!(
events[0].as_log()[&event::log_schema().message_key()],
message.into()
);
});
}
#[test]
fn include_labels() {
trace_init();
let message = "12";
let name0 = "vector_test_include_labels_0";
let name1 = "vector_test_include_labels_1";
let label = "vector_test_include_label";
let mut rt = runtime();
let out = source_with(&[name0, name1], label, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id0 = container_log_n(1, name0, None, "13", &docker).await;
let id1 = container_log_n(1, name1, Some(label), message, &docker).await;
let events = collect_n(out, 1).compat().await.ok().unwrap();
container_remove(&id0, &docker).await;
container_remove(&id1, &docker).await;
assert_eq!(
events[0].as_log()[&event::log_schema().message_key()],
message.into()
);
});
}
#[test]
fn currently_running() {
trace_init();
let message = "14";
let name = "vector_test_currently_running";
let label = "vector_test_label_currently_running";
let mut rt = runtime();
let docker = docker().unwrap();
let id = running_container(name, Some(label), message, &docker, &mut rt);
let out = source_with(&[name], None, &mut rt);
rt.block_on_std(async move {
let events = collect_n(out, 1).compat().await.ok().unwrap();
let _ = container_kill(&id, &docker).await;
container_remove(&id, &docker).await;
let log = events[0].as_log();
assert_eq!(log[&event::log_schema().message_key()], message.into());
assert_eq!(log[&super::CONTAINER], id.into());
assert!(log.get(&super::CREATED_AT).is_some());
assert_eq!(log[&super::IMAGE], "busybox".into());
assert!(log.get(&format!("label.{}", label).into()).is_some());
assert_eq!(events[0].as_log()[&super::NAME], name.into());
assert_eq!(
events[0].as_log()[event::log_schema().source_type_key()],
"docker".into()
);
});
}
#[test]
fn include_image() {
trace_init();
let message = "15";
let name = "vector_test_include_image";
let config = DockerConfig {
include_containers: Some(vec![name.to_owned()]),
include_images: Some(vec!["busybox".to_owned()]),
..DockerConfig::default()
};
let mut rt = runtime();
let out = source_with_config(config, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id = container_log_n(1, name, None, message, &docker).await;
let events = collect_n(out, 1).compat().await.ok().unwrap();
container_remove(&id, &docker).await;
assert_eq!(
events[0].as_log()[&event::log_schema().message_key()],
message.into()
);
});
}
#[test]
fn not_include_image() {
trace_init();
let message = "16";
let name = "vector_test_not_include_image";
let config_ex = DockerConfig {
include_images: Some(vec!["some_image".to_owned()]),
..DockerConfig::default()
};
let mut rt = runtime();
let exclude_out = source_with_config(config_ex, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id = container_log_n(1, name, None, message, &docker).await;
container_remove(&id, &docker).await;
assert!(is_empty(exclude_out).await.unwrap());
});
}
#[test]
fn not_include_running_image() {
trace_init();
let message = "17";
let name = "vector_test_not_include_running_image";
let config_ex = DockerConfig {
include_images: Some(vec!["some_image".to_owned()]),
..DockerConfig::default()
};
let config_in = DockerConfig {
include_containers: Some(vec![name.to_owned()]),
include_images: Some(vec!["busybox".to_owned()]),
..DockerConfig::default()
};
let mut rt = runtime();
let docker = docker().unwrap();
let id = running_container(name, None, message, &docker, &mut rt);
let exclude_out = source_with_config(config_ex, &mut rt);
let include_out = source_with_config(config_in, &mut rt);
rt.block_on_std(async move {
let _ = collect_n(include_out, 1).compat().await.ok().unwrap();
let _ = container_kill(&id, &docker).await;
container_remove(&id, &docker).await;
assert!(is_empty(exclude_out).await.unwrap());
});
}
#[test]
fn log_longer_than_16kb() {
trace_init();
let mut message = String::with_capacity(20 * 1024);
for _ in 0..message.capacity() {
message.push('0');
}
let name = "vector_test_log_longer_than_16kb";
let mut rt = runtime();
let out = source_with(&[name], None, &mut rt);
rt.block_on_std(async move {
let docker = docker().unwrap();
let id = container_log_n(1, name, None, message.as_str(), &docker).await;
let events = collect_n(out, 1).compat().await.ok().unwrap();
container_remove(&id, &docker).await;
let log = events[0].as_log();
assert_eq!(log[&event::log_schema().message_key()], message.into());
});
}
}
|
//! Contains the ffi-safe equivalent of `std::collections::HashMap`, and related items.
#![allow(clippy::missing_const_for_fn)]
use std::{
borrow::Borrow,
cmp::{Eq, PartialEq},
collections::{hash_map::RandomState, HashMap},
fmt::{self, Debug},
hash::{BuildHasher, Hash, Hasher},
iter::FromIterator,
marker::PhantomData,
mem,
ops::{Index, IndexMut},
ptr::NonNull,
};
#[allow(unused_imports)]
use core_extensions::SelfOps;
use crate::{
erased_types::trait_objects::HasherObject,
marker_type::{
ErasedObject, ErasedPrefix, NonOwningPhantom, NotCopyNotClone, UnsafeIgnoredType,
},
pointer_trait::{AsMutPtr, AsPtr},
prefix_type::{PrefixRef, WithMetadata},
sabi_types::{RMut, RRef},
std_types::*,
traits::{ErasedType, IntoReprRust},
DynTrait, StableAbi,
};
mod entry;
mod extern_fns;
mod iterator_stuff;
mod map_key;
mod map_query;
#[cfg(all(test, not(feature = "only_new_tests")))]
mod test;
use self::{entry::BoxedREntry, map_key::MapKey, map_query::MapQuery};
pub use self::{
entry::{REntry, ROccupiedEntry, RVacantEntry},
iterator_stuff::{IntoIter, MutIterInterface, RefIterInterface, ValIterInterface},
};
/// An ffi-safe hashmap, which wraps `std::collections::HashMap<K, V, S>`,
/// only requiring the `K: Eq + Hash` bounds when constructing it.
///
/// Most of the API in `HashMap` is implemented here, including the Entry API.
///
///
/// # Example
///
/// This example demonstrates how one can use the RHashMap as a dictionary.
///
/// ```
/// use abi_stable::std_types::{RHashMap, RSome, RString, Tuple2};
///
/// let mut map = RHashMap::new();
///
/// map.insert(
/// "dictionary",
/// "A book/document containing definitions of words",
/// );
/// map.insert("bibliophile", "Someone who loves books.");
/// map.insert("pictograph", "A picture representating of a word.");
///
/// assert_eq!(
/// map["dictionary"],
/// "A book/document containing definitions of words",
/// );
///
/// assert_eq!(map.remove("bibliophile"), RSome("Someone who loves books."),);
///
/// assert_eq!(
/// map.get("pictograph"),
/// Some(&"A picture representating of a word."),
/// );
///
/// for Tuple2(k, v) in map {
/// assert!(k == "dictionary" || k == "pictograph");
///
/// assert!(
/// v == "A book/document containing definitions of words" ||
/// v == "A picture representating of a word.",
/// "{} => {}",
/// k,
/// v,
/// );
/// }
///
///
/// ```
///
#[derive(StableAbi)]
#[repr(C)]
#[sabi(
// The hasher doesn't matter
unsafe_unconstrained(S),
)]
pub struct RHashMap<K, V, S = RandomState> {
map: RBox<ErasedMap<K, V, S>>,
#[sabi(unsafe_change_type = VTable_Ref<K, V, S>)]
vtable: PrefixRef<ErasedPrefix>,
}
///////////////////////////////////////////////////////////////////////////////
struct BoxedHashMap<'a, K, V, S> {
map: HashMap<MapKey<K>, V, S>,
entry: Option<BoxedREntry<'a, K, V>>,
}
/// An RHashMap iterator,
/// implementing `Iterator<Item= Tuple2< &K, &V > > + !Send + !Sync + Clone`
pub type Iter<'a, K, V> = DynTrait<'a, RBox<()>, RefIterInterface<K, V>>;
/// An RHashMap iterator,
/// implementing `Iterator<Item= Tuple2< &K, &mut V > > + !Send + !Sync`
pub type IterMut<'a, K, V> = DynTrait<'a, RBox<()>, MutIterInterface<K, V>>;
/// An RHashMap iterator,
/// implementing `Iterator<Item= Tuple2< K, V > > + !Send + !Sync`
pub type Drain<'a, K, V> = DynTrait<'a, RBox<()>, ValIterInterface<K, V>>;
/// Used as the erased type of the RHashMap type.
#[repr(C)]
#[derive(StableAbi)]
#[sabi(
// The hasher doesn't matter
unsafe_unconstrained(S),
)]
struct ErasedMap<K, V, S>(PhantomData<(K, V)>, UnsafeIgnoredType<S>);
impl<'a, K: 'a, V: 'a, S: 'a> ErasedType<'a> for ErasedMap<K, V, S> {
type Unerased = BoxedHashMap<'a, K, V, S>;
}
///////////////////////////////////////////////////////////////////////////////
impl<K, V> RHashMap<K, V, RandomState> {
/// Constructs an empty RHashMap.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
///
/// let mut map = RHashMap::<RString, u32>::new();
/// assert!(map.is_empty());
/// map.insert("Hello".into(), 10);
/// assert_eq!(map.is_empty(), false);
///
/// ```
#[inline]
pub fn new() -> RHashMap<K, V>
where
Self: Default,
{
Self::default()
}
/// Constructs an empty RHashMap with at least the passed capacity.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
///
/// let mut map = RHashMap::<RString, u32>::with_capacity(10);
/// assert!(map.capacity() >= 10);
///
/// ```
#[inline]
pub fn with_capacity(capacity: usize) -> RHashMap<K, V>
where
Self: Default,
{
let mut this = Self::default();
this.reserve(capacity);
this
}
}
impl<K, V, S> RHashMap<K, V, S> {
/// Constructs an empty RHashMap with the passed `hash_builder` to hash the keys.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
/// use std::collections::hash_map::RandomState;
///
/// let s = RandomState::new();
/// let mut map = RHashMap::<RString, u32, _>::with_hasher(s);
/// assert!(map.is_empty());
/// map.insert("Hello".into(), 10);
/// assert_eq!(map.is_empty(), false);
///
/// ```
#[inline]
pub fn with_hasher(hash_builder: S) -> RHashMap<K, V, S>
where
K: Eq + Hash,
S: BuildHasher + Default,
{
Self::with_capacity_and_hasher(0, hash_builder)
}
/// Constructs an empty RHashMap with at least the passed capacity,
/// and the passed `hash_builder` to hash the keys.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
/// use std::collections::hash_map::RandomState;
///
/// let s = RandomState::new();
/// let mut map = RHashMap::<RString, u32, _>::with_capacity_and_hasher(10, s);
/// assert!(map.capacity() >= 10);
///
/// ```
pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> RHashMap<K, V, S>
where
K: Eq + Hash,
S: BuildHasher + Default,
{
let mut map = VTable::<K, V, S>::erased_map(hash_builder);
unsafe {
ErasedMap::reserve(map.as_rmut(), capacity);
RHashMap {
map,
vtable: VTable::<K, V, S>::VTABLE_REF.0.cast(),
}
}
}
}
impl<K, V, S> RHashMap<K, V, S> {
fn vtable(&self) -> VTable_Ref<K, V, S> {
unsafe { VTable_Ref::<K, V, S>(self.vtable.cast()) }
}
}
impl<K, V, S> RHashMap<K, V, S> {
/// Returns whether the map associates a value with the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
///
/// let mut map = RHashMap::<RString, u32>::new();
/// assert_eq!(map.contains_key("boo"), false);
/// map.insert("boo".into(), 0);
/// assert_eq!(map.contains_key("boo"), true);
///
/// ```
pub fn contains_key<Q>(&self, query: &Q) -> bool
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
self.get(query).is_some()
}
/// Returns a reference to the value associated with the key.
///
/// Returns a `None` if there is no entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
///
/// let mut map = RHashMap::<RString, u32>::new();
/// assert_eq!(map.get("boo"), None);
/// map.insert("boo".into(), 0);
/// assert_eq!(map.get("boo"), Some(&0));
///
/// ```
pub fn get<Q>(&self, query: &Q) -> Option<&V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let vtable = self.vtable();
unsafe { vtable.get_elem()(self.map.as_rref(), MapQuery::new(&query)) }
}
/// Returns a mutable reference to the value associated with the key.
///
/// Returns a `None` if there is no entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RString};
///
/// let mut map = RHashMap::<RString, u32>::new();
/// assert_eq!(map.get_mut("boo"), None);
/// map.insert("boo".into(), 0);
/// assert_eq!(map.get_mut("boo"), Some(&mut 0));
///
/// ```
pub fn get_mut<Q>(&mut self, query: &Q) -> Option<&mut V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let vtable = self.vtable();
unsafe { vtable.get_mut_elem()(self.map.as_rmut(), MapQuery::new(&query)) }
}
/// Removes the value associated with the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RSome, RNone};
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.remove(&0), RSome(1));
/// assert_eq!(map.remove(&0), RNone);
///
/// assert_eq!(map.remove(&3), RSome(4));
/// assert_eq!(map.remove(&3), RNone);
///
/// ```
pub fn remove<Q>(&mut self, query: &Q) -> ROption<V>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
self.remove_entry(query).map(|x| x.1)
}
/// Removes the entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RSome, RNone, Tuple2};
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.remove_entry(&0), RSome(Tuple2(0, 1)));
/// assert_eq!(map.remove_entry(&0), RNone);
///
/// assert_eq!(map.remove_entry(&3), RSome(Tuple2(3, 4)));
/// assert_eq!(map.remove_entry(&3), RNone);
///
/// ```
pub fn remove_entry<Q>(&mut self, query: &Q) -> ROption<Tuple2<K, V>>
where
K: Borrow<Q>,
Q: Hash + Eq + ?Sized,
{
let vtable = self.vtable();
unsafe { vtable.remove_entry()(self.map.as_rmut(), MapQuery::new(&query)) }
}
}
impl<K, V, S> RHashMap<K, V, S> {
/// Returns whether the map associates a value with the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
/// assert_eq!(map.contains_key(&11), false);
/// map.insert(11, 0);
/// assert_eq!(map.contains_key(&11), true);
///
/// ```
pub fn contains_key_p(&self, key: &K) -> bool {
self.get_p(key).is_some()
}
/// Returns a reference to the value associated with the key.
///
/// Returns a `None` if there is no entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
/// assert_eq!(map.get(&12), None);
/// map.insert(12, 0);
/// assert_eq!(map.get(&12), Some(&0));
///
/// ```
pub fn get_p(&self, key: &K) -> Option<&V> {
let vtable = self.vtable();
unsafe { vtable.get_elem_p()(self.map.as_rref(), key) }
}
/// Returns a mutable reference to the value associated with the key.
///
/// Returns a `None` if there is no entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
/// assert_eq!(map.get_mut(&12), None);
/// map.insert(12, 0);
/// assert_eq!(map.get_mut(&12), Some(&mut 0));
///
/// ```
pub fn get_mut_p(&mut self, key: &K) -> Option<&mut V> {
let vtable = self.vtable();
unsafe { vtable.get_mut_elem_p()(self.map.as_rmut(), key) }
}
/// Removes the value associated with the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RSome, RNone};
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.remove_p(&0), RSome(1));
/// assert_eq!(map.remove_p(&0), RNone);
///
/// assert_eq!(map.remove_p(&3), RSome(4));
/// assert_eq!(map.remove_p(&3), RNone);
///
/// ```
pub fn remove_p(&mut self, key: &K) -> ROption<V> {
self.remove_entry_p(key).map(|x| x.1)
}
/// Removes the entry for the key.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, RSome, RNone, Tuple2};
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.remove_entry_p(&0), RSome(Tuple2(0, 1)));
/// assert_eq!(map.remove_entry_p(&0), RNone);
///
/// assert_eq!(map.remove_entry_p(&3), RSome(Tuple2(3, 4)));
/// assert_eq!(map.remove_entry_p(&3), RNone);
///
/// ```
pub fn remove_entry_p(&mut self, key: &K) -> ROption<Tuple2<K, V>> {
let vtable = self.vtable();
unsafe { vtable.remove_entry_p()(self.map.as_rmut(), key) }
}
/// Returns a reference to the value associated with the key.
///
/// # Panics
///
/// Panics if the key is not associated with a value.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.index_p(&0), &1);
/// assert_eq!(map.index_p(&3), &4);
///
/// ```
///
/// ```should_panic
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// assert_eq!(map.index_p(&0), &1);
///
/// ```
pub fn index_p(&self, key: &K) -> &V {
self.get_p(key)
.expect("no entry in RHashMap<_, _> found for key")
}
/// Returns a mutable reference to the value associated with the key.
///
/// # Panics
///
/// Panics if the key is not associated with a value.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.index_mut_p(&0), &mut 1);
/// assert_eq!(map.index_mut_p(&3), &mut 4);
///
/// ```
///
/// ```should_panic
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// assert_eq!(map.index_mut_p(&0), &mut 1);
///
/// ```
pub fn index_mut_p(&mut self, key: &K) -> &mut V {
self.get_mut_p(key)
.expect("no entry in RHashMap<_, _> found for key")
}
//////////////////////////////////
/// Inserts a value into the map, associating it with a key, returning the previous value.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// map.insert(0, 1);
/// map.insert(2, 3);
///
/// assert_eq!(map[&0], 1);
/// assert_eq!(map[&2], 3);
///
/// ```
pub fn insert(&mut self, key: K, value: V) -> ROption<V> {
let vtable = self.vtable();
unsafe { vtable.insert_elem()(self.map.as_rmut(), key, value) }
}
/// Reserves enough space to insert `reserved` extra elements without reallocating.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
/// map.reserve(10);
///
/// ```
pub fn reserve(&mut self, reserved: usize) {
let vtable = self.vtable();
unsafe {
vtable.reserve()(self.map.as_rmut(), reserved);
}
}
/// Removes all the entries in the map.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = vec![(0, 1), (3, 4)].into_iter().collect::<RHashMap<u32, u32>>();
///
/// assert_eq!(map.contains_key(&0), true);
/// assert_eq!(map.contains_key(&3), true);
///
/// map.clear();
///
/// assert_eq!(map.contains_key(&0), false);
/// assert_eq!(map.contains_key(&3), false);
///
/// ```
pub fn clear(&mut self) {
let vtable = self.vtable();
unsafe {
vtable.clear_map()(self.map.as_rmut());
}
}
/// Returns the amount of entries in the map.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// assert_eq!(map.len(), 0);
/// map.insert(0, 1);
/// assert_eq!(map.len(), 1);
/// map.insert(2, 3);
/// assert_eq!(map.len(), 2);
///
/// ```
pub fn len(&self) -> usize {
let vtable = self.vtable();
unsafe { vtable.len()(self.map.as_rref()) }
}
/// Returns the capacity of the map, the amount of elements it can store without reallocating.
///
/// Note that this is a lower bound, since hash maps don't necessarily have an exact capacity.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::with_capacity(4);
///
/// assert!(map.capacity() >= 4);
///
/// ```
pub fn capacity(&self) -> usize {
let vtable = self.vtable();
unsafe { vtable.capacity()(self.map.as_rref()) }
}
/// Returns whether the map contains any entries.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// assert_eq!(map.is_empty(), true);
/// map.insert(0, 1);
/// assert_eq!(map.is_empty(), false);
///
/// ```
pub fn is_empty(&self) -> bool {
self.len() == 0
}
/// Iterates over the entries in the map, with references to the values in the map.
///
/// This returns a type that implements
/// `Iterator<Item= Tuple2< &K, &V > > + !Send + !Sync + Clone`
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, Tuple2};
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// map.insert(0, 1);
/// map.insert(3, 4);
///
/// let mut list = map.iter().collect::<Vec<_>>();
/// list.sort();
/// assert_eq!( list, vec![Tuple2(&0, &1), Tuple2(&3, &4)] );
///
/// ```
pub fn iter(&self) -> Iter<'_, K, V> {
let vtable = self.vtable();
unsafe { vtable.iter()(self.map.as_rref()) }
}
/// Iterates over the entries in the map, with mutable references to the values in the map.
///
/// This returns a type that implements
/// `Iterator<Item= Tuple2< &K, &mut V > > + !Send + !Sync`
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, Tuple2};
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// map.insert(0, 1);
/// map.insert(3, 4);
///
/// let mut list = map.iter_mut().collect::<Vec<_>>();
/// list.sort();
/// assert_eq!( list, vec![Tuple2(&0, &mut 1), Tuple2(&3, &mut 4)] );
///
/// ```
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
let vtable = self.vtable();
unsafe { vtable.iter_mut()(self.map.as_rmut()) }
}
/// Clears the map, returning an iterator over all the entries that were removed.
///
/// This returns a type that implements `Iterator<Item= Tuple2< K, V > > + !Send + !Sync`
///
/// # Example
///
/// ```
/// use abi_stable::std_types::{RHashMap, Tuple2};
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// map.insert(0, 1);
/// map.insert(3, 4);
///
/// let mut list = map.drain().collect::<Vec<_>>();
/// list.sort();
/// assert_eq!( list, vec![Tuple2(0, 1), Tuple2(3, 4)] );
///
/// assert!(map.is_empty());
///
/// ```
pub fn drain(&mut self) -> Drain<'_, K, V> {
let vtable = self.vtable();
unsafe { vtable.drain()(self.map.as_rmut()) }
}
/// Gets a handle into the entry in the map for the key,
/// that allows operating directly on the entry.
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::<u32, u32>::new();
///
/// // Inserting an entry that wasn't there before.
/// {
/// let mut entry = map.entry(0);
/// assert_eq!(entry.get(), None);
/// assert_eq!(entry.or_insert(3), &mut 3);
/// assert_eq!(map.get(&0), Some(&3));
/// }
///
///
/// ```
///
pub fn entry(&mut self, key: K) -> REntry<'_, K, V> {
let vtable = self.vtable();
unsafe { vtable.entry()(self.map.as_rmut(), key) }
}
/// An iterator visiting all keys in arbitrary order.
/// The iterator element type is `&'a K`.
///
/// # Examples
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::new();
/// map.insert("a", 1);
/// map.insert("b", 2);
/// map.insert("c", 3);
///
/// for key in map.keys() {
/// println!("{}", key);
/// }
/// ```
pub fn keys(&self) -> Keys<'_, K, V> {
Keys { inner: self.iter() }
}
/// An iterator visiting all values in arbitrary order.
/// The iterator element type is `&'a V`.
///
/// # Examples
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::new();
/// map.insert("a", 1);
/// map.insert("b", 2);
/// map.insert("c", 3);
///
/// for val in map.values() {
/// println!("{}", val);
/// }
/// ```
pub fn values(&self) -> Values<'_, K, V> {
Values { inner: self.iter() }
}
}
/// An iterator over the keys of a `RHashMap`.
///
/// This `struct` is created by the [`keys`] method on [`RHashMap`]. See its
/// documentation for more.
///
/// [`keys`]: RHashMap::keys
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::new();
/// map.insert("a", 1);
/// let iter_keys = map.keys();
/// ```
#[repr(C)]
#[derive(StableAbi)]
pub struct Keys<'a, K: 'a, V: 'a> {
inner: Iter<'a, K, V>,
}
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
impl<K, V> Clone for Keys<'_, K, V> {
#[inline]
fn clone(&self) -> Self {
Keys {
inner: self.inner.clone(),
}
}
}
impl<K: Debug, V> fmt::Debug for Keys<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
#[inline]
fn next(&mut self) -> Option<&'a K> {
self.inner.next().map(|tuple| tuple.0)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
/// An iterator over the values of a `HashMap`.
///
/// This `struct` is created by the [`values`] method on [`HashMap`]. See its
/// documentation for more.
///
/// [`values`]: HashMap::values
///
/// # Example
///
/// ```
/// use abi_stable::std_types::RHashMap;
///
/// let mut map = RHashMap::new();
/// map.insert("a", 1);
/// let iter_values = map.values();
/// ```
#[repr(C)]
#[derive(StableAbi)]
pub struct Values<'a, K: 'a, V: 'a> {
inner: Iter<'a, K, V>,
}
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
impl<K, V> Clone for Values<'_, K, V> {
#[inline]
fn clone(&self) -> Self {
Values {
inner: self.inner.clone(),
}
}
}
impl<K, V: Debug> fmt::Debug for Values<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
#[inline]
fn next(&mut self) -> Option<&'a V> {
self.inner.next().map(|tuple| tuple.1)
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
}
/// This returns an `Iterator<Item= Tuple2< K, V > >+!Send+!Sync`
impl<K, V, S> IntoIterator for RHashMap<K, V, S> {
type Item = Tuple2<K, V>;
type IntoIter = IntoIter<K, V>;
fn into_iter(self) -> IntoIter<K, V> {
let vtable = self.vtable();
unsafe { vtable.iter_val()(self.map) }
}
}
/// This returns an `Iterator<Item= Tuple2< &K, &V > > + !Send + !Sync + Clone`
impl<'a, K, V, S> IntoIterator for &'a RHashMap<K, V, S> {
type Item = Tuple2<&'a K, &'a V>;
type IntoIter = Iter<'a, K, V>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
/// This returns a type that implements
/// `Iterator<Item= Tuple2< &K, &mut V > > + !Send + !Sync`
impl<'a, K, V, S> IntoIterator for &'a mut RHashMap<K, V, S> {
type Item = Tuple2<&'a K, &'a mut V>;
type IntoIter = IterMut<'a, K, V>;
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
impl<K, V, S> From<HashMap<K, V, S>> for RHashMap<K, V, S>
where
Self: Default,
{
fn from(map: HashMap<K, V, S>) -> Self {
map.into_iter().collect()
}
}
impl<K, V, S> From<RHashMap<K, V, S>> for HashMap<K, V, S>
where
K: Eq + Hash,
S: BuildHasher + Default,
{
fn from(this: RHashMap<K, V, S>) -> HashMap<K, V, S> {
this.into_iter().map(|x| x.into_tuple()).collect()
}
}
impl<K, V, S> FromIterator<(K, V)> for RHashMap<K, V, S>
where
Self: Default,
{
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = (K, V)>,
{
let mut map = Self::default();
map.extend(iter);
map
}
}
impl<K, V, S> FromIterator<Tuple2<K, V>> for RHashMap<K, V, S>
where
Self: Default,
{
fn from_iter<I>(iter: I) -> Self
where
I: IntoIterator<Item = Tuple2<K, V>>,
{
let mut map = Self::default();
map.extend(iter);
map
}
}
impl<K, V, S> Extend<(K, V)> for RHashMap<K, V, S> {
fn extend<I>(&mut self, iter: I)
where
I: IntoIterator<Item = (K, V)>,
{
let iter = iter.into_iter();
self.reserve(iter.size_hint().0);
for (k, v) in iter {
self.insert(k, v);
}
}
}
impl<K, V, S> Extend<Tuple2<K, V>> for RHashMap<K, V, S> {
#[inline]
fn extend<I>(&mut self, iter: I)
where
I: IntoIterator<Item = Tuple2<K, V>>,
{
self.extend(iter.into_iter().map(Tuple2::into_rust));
}
}
impl<K, V, S> Default for RHashMap<K, V, S>
where
K: Eq + Hash,
S: BuildHasher + Default,
{
fn default() -> Self {
Self::with_hasher(S::default())
}
}
impl<K, V, S> Clone for RHashMap<K, V, S>
where
K: Clone,
V: Clone,
Self: Default,
{
fn clone(&self) -> Self {
self.iter()
.map(|Tuple2(k, v)| (k.clone(), v.clone()))
.collect()
}
}
impl<K, V, S> Debug for RHashMap<K, V, S>
where
K: Debug,
V: Debug,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map()
.entries(self.iter().map(Tuple2::into_rust))
.finish()
}
}
impl<K, V, S> Eq for RHashMap<K, V, S>
where
K: Eq,
V: Eq,
{
}
impl<K, V, S> PartialEq for RHashMap<K, V, S>
where
K: PartialEq,
V: PartialEq,
{
fn eq(&self, other: &Self) -> bool {
if self.len() != other.len() {
return false;
}
self.iter()
.all(|Tuple2(k, vl)| other.get_p(k).map_or(false, |vr| *vr == *vl))
}
}
unsafe impl<K, V, S> Send for RHashMap<K, V, S> where HashMap<K, V, S>: Send {}
unsafe impl<K, V, S> Sync for RHashMap<K, V, S> where HashMap<K, V, S>: Sync {}
impl<K, Q, V, S> Index<&Q> for RHashMap<K, V, S>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
type Output = V;
fn index(&self, query: &Q) -> &V {
self.get(query)
.expect("no entry in RHashMap<_, _> found for key")
}
}
impl<K, Q, V, S> IndexMut<&Q> for RHashMap<K, V, S>
where
K: Borrow<Q>,
Q: Eq + Hash + ?Sized,
{
fn index_mut(&mut self, query: &Q) -> &mut V {
self.get_mut(query)
.expect("no entry in RHashMap<_, _> found for key")
}
}
mod serde {
use super::*;
use ::serde::{
de::{MapAccess, Visitor},
ser::SerializeMap,
Deserialize, Deserializer, Serialize, Serializer,
};
struct RHashMapVisitor<K, V, S> {
_marker: NonOwningPhantom<RHashMap<K, V, S>>,
}
impl<K, V, S> RHashMapVisitor<K, V, S> {
fn new() -> Self {
RHashMapVisitor {
_marker: NonOwningPhantom::NEW,
}
}
}
impl<'de, K, V, S> Visitor<'de> for RHashMapVisitor<K, V, S>
where
K: Deserialize<'de>,
V: Deserialize<'de>,
RHashMap<K, V, S>: Default,
{
type Value = RHashMap<K, V, S>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("an RHashMap")
}
fn visit_map<M>(self, mut map_access: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
let capacity = map_access.size_hint().unwrap_or(0);
let mut map = RHashMap::default();
map.reserve(capacity);
while let Some((k, v)) = map_access.next_entry()? {
map.insert(k, v);
}
Ok(map)
}
}
impl<'de, K, V, S> Deserialize<'de> for RHashMap<K, V, S>
where
K: Deserialize<'de>,
V: Deserialize<'de>,
Self: Default,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_map(RHashMapVisitor::new())
}
}
impl<K, V, S> Serialize for RHashMap<K, V, S>
where
K: Serialize,
V: Serialize,
{
fn serialize<Z>(&self, serializer: Z) -> Result<Z::Ok, Z::Error>
where
Z: Serializer,
{
let mut map = serializer.serialize_map(Some(self.len()))?;
for Tuple2(k, v) in self.iter() {
map.serialize_entry(k, v)?;
}
map.end()
}
}
}
///////////////////////////////////////////////////////////////////////////////
#[derive(StableAbi)]
#[repr(C)]
#[sabi(
kind(Prefix),
missing_field(panic),
// The hasher doesn't matter
unsafe_unconstrained(S),
//debug_print,
)]
struct VTable<K, V, S> {
///
insert_elem: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>, K, V) -> ROption<V>,
get_elem: for<'a> unsafe extern "C" fn(
RRef<'a, ErasedMap<K, V, S>>,
MapQuery<'_, K>,
) -> Option<&'a V>,
get_mut_elem: for<'a> unsafe extern "C" fn(
RMut<'a, ErasedMap<K, V, S>>,
MapQuery<'_, K>,
) -> Option<&'a mut V>,
remove_entry: unsafe extern "C" fn(
RMut<'_, ErasedMap<K, V, S>>,
MapQuery<'_, K>,
) -> ROption<Tuple2<K, V>>,
get_elem_p: for<'a> unsafe extern "C" fn(RRef<'a, ErasedMap<K, V, S>>, &K) -> Option<&'a V>,
get_mut_elem_p:
for<'a> unsafe extern "C" fn(RMut<'a, ErasedMap<K, V, S>>, &K) -> Option<&'a mut V>,
remove_entry_p: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>, &K) -> ROption<Tuple2<K, V>>,
reserve: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>, usize),
clear_map: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>),
len: unsafe extern "C" fn(RRef<'_, ErasedMap<K, V, S>>) -> usize,
capacity: unsafe extern "C" fn(RRef<'_, ErasedMap<K, V, S>>) -> usize,
iter: unsafe extern "C" fn(RRef<'_, ErasedMap<K, V, S>>) -> Iter<'_, K, V>,
iter_mut: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>) -> IterMut<'_, K, V>,
drain: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>) -> Drain<'_, K, V>,
iter_val: unsafe extern "C" fn(RBox<ErasedMap<K, V, S>>) -> IntoIter<K, V>,
#[sabi(last_prefix_field)]
entry: unsafe extern "C" fn(RMut<'_, ErasedMap<K, V, S>>, K) -> REntry<'_, K, V>,
}
impl<K, V, S> VTable<K, V, S>
where
K: Eq + Hash,
S: BuildHasher,
{
const VTABLE_VAL: WithMetadata<VTable<K, V, S>> = WithMetadata::new(Self::VTABLE);
const VTABLE_REF: VTable_Ref<K, V, S> = unsafe { VTable_Ref(Self::VTABLE_VAL.as_prefix()) };
fn erased_map(hash_builder: S) -> RBox<ErasedMap<K, V, S>> {
unsafe {
let map = HashMap::<MapKey<K>, V, S>::with_hasher(hash_builder);
let boxed = BoxedHashMap { map, entry: None };
let boxed = RBox::new(boxed);
mem::transmute::<RBox<_>, RBox<ErasedMap<K, V, S>>>(boxed)
}
}
const VTABLE: VTable<K, V, S> = VTable {
insert_elem: ErasedMap::insert_elem,
get_elem: ErasedMap::get_elem,
get_mut_elem: ErasedMap::get_mut_elem,
remove_entry: ErasedMap::remove_entry,
get_elem_p: ErasedMap::get_elem_p,
get_mut_elem_p: ErasedMap::get_mut_elem_p,
remove_entry_p: ErasedMap::remove_entry_p,
reserve: ErasedMap::reserve,
clear_map: ErasedMap::clear_map,
len: ErasedMap::len,
capacity: ErasedMap::capacity,
iter: ErasedMap::iter,
iter_mut: ErasedMap::iter_mut,
drain: ErasedMap::drain,
iter_val: ErasedMap::iter_val,
entry: ErasedMap::entry,
};
}
///////////////////////////////////////////////////////////////////////////////
|
//! Handles talking to local data store.
use chrono;
use futures::future::LocalBoxFuture;
use linear_map::LinearMap;
use r2d2;
use rusqlite;
use serde;
use serde::Serialize;
use snafu::{Backtrace, Snafu};
// mod postgres;
mod sqlite;
// pub use self::postgres::PostgresDatabase;
pub use self::sqlite::SqliteDatabase;
/// A single transaction between two users.
#[derive(Clone, Debug, Serialize)]
pub struct Transaction {
/// The user who is creating the transaction.
pub shafter: String,
/// The other party in the transaction.
pub shaftee: String,
/// The amount of money in pence. Positive means shafter is owed the amount,
/// negative means shafter owes the amount.
pub amount: i64,
/// Time transaction happened.
#[serde(serialize_with = "serialize_time")]
pub datetime: chrono::DateTime<chrono::Utc>,
/// A human readable description of the transaction.
pub reason: String,
}
/// A user and their balance
#[derive(Debug, Clone, Serialize)]
pub struct User {
/// Their internal shaft user ID
pub user_id: String,
/// Their display name
pub display_name: String,
/// Their current balance
pub balance: i64,
}
/// A generic datastore for the app
pub trait Database: Send + Sync {
/// Get local user ID by their Github login ID
fn get_user_by_github_id(
&self,
github_user_id: String,
) -> LocalBoxFuture<'static, Result<Option<String>, DatabaseError>>;
/// Add a new user from github
fn add_user_by_github_id(
&self,
github_user_id: String,
display_name: String,
) -> LocalBoxFuture<'static, Result<String, DatabaseError>>;
/// Create a new Shaft access token
fn create_token_for_user(
&self,
user_id: String,
) -> LocalBoxFuture<'static, Result<String, DatabaseError>>;
/// Delete a Shaft access token.
fn delete_token(&self, token: String) -> LocalBoxFuture<'static, Result<(), DatabaseError>>;
/// Get a user by Shaft access token.
fn get_user_from_token(
&self,
token: String,
) -> LocalBoxFuture<'static, Result<Option<User>, DatabaseError>>;
/// Get a user's balance in pence
fn get_balance_for_user(
&self,
user: String,
) -> LocalBoxFuture<'static, Result<i64, DatabaseError>>;
/// Get a map of all users from local user ID to [User] object
fn get_all_users(
&self,
) -> LocalBoxFuture<'static, Result<LinearMap<String, User>, DatabaseError>>;
/// Commit a new Shaft [Transaction]
fn shaft_user(
&self,
transaction: Transaction,
) -> LocalBoxFuture<'static, Result<(), DatabaseError>>;
/// Get a list of the most recent Shaft transactions
fn get_last_transactions(
&self,
limit: u32,
) -> LocalBoxFuture<'static, Result<Vec<Transaction>, DatabaseError>>;
}
/// Error using database.
#[derive(Debug, Snafu)]
pub enum DatabaseError {
/// Error getting a database connection.
#[snafu(display("DB Pool error: {}", source))]
ConnectionPoolError {
source: r2d2::Error,
backtrace: Backtrace,
},
/// SQLite error.
#[snafu(display("Sqlite error: {}", source))]
SqliteError {
source: rusqlite::Error,
backtrace: Backtrace,
},
/// Postgres error.
#[snafu(display("Postgres error: {}", source))]
PostgresError {
source: ::postgres::Error,
backtrace: Backtrace,
},
/// One of the users is unknown.
#[snafu(display("Unknown user: {}", user_id))]
UnknownUser { user_id: String },
}
/// Serialize time into timestamp.
fn serialize_time<S>(date: &chrono::DateTime<chrono::Utc>, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
serializer.serialize_i64(date.timestamp())
}
|
// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#![feature(async_await, await_macro, futures_api)]
#![deny(warnings)]
#![recursion_limit="256"]
use {
failure::{Error, ResultExt},
fdio,
fidl::endpoints::{RequestStream, ServiceMarker},
fidl_fuchsia_hardware_vsock::DeviceMarker,
fidl_fuchsia_vsock::{ConnectorMarker, ConnectorRequestStream},
fuchsia_app::server::ServicesServer,
fuchsia_async as fasync,
fuchsia_syslog::{self as syslog, fx_log_err, fx_log_info},
fuchsia_zircon as zx,
futures::TryFutureExt,
};
use vsock_service_lib as service;
#[fasync::run_singlethreaded]
async fn main() -> Result<(), Error> {
syslog::init().expect("Unable to initialize syslog");
fx_log_info!("Starting vsock service");
let (client, device) = zx::Channel::create()?;
fdio::service_connect("/dev/class/vsock/000", device)?;
let dev = fidl::endpoints::ClientEnd::<DeviceMarker>::new(client)
.into_proxy()
.context("Failed to make channel")?;
let (service, event_loop) =
await!(service::Vsock::new(dev)).context("Failed to initialize vsock service")?;
let service_clone = service.clone();
let server = ServicesServer::new()
.add_service((ConnectorMarker::NAME, move |chan| {
fasync::spawn(
service_clone
.clone()
.run_client_connection(ConnectorRequestStream::from_channel(chan))
.unwrap_or_else(|err| fx_log_info!("Error {} during client connection", err)),
);
}))
.start()
.context("Error starting ServicesServer")?;
// Spawn the services server with a wrapper to discard the return value.
fasync::spawn(
async {
if let Err(err) = await!(server) {
fx_log_err!("Services server failed with {}", err);
}
},
);
// Run the event loop until completion. The event loop only terminates
// with an error.
await!(event_loop)?;
Ok(())
}
|
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use crate::{AccessibilityOptions, CaptionCommands};
use failure::Error;
use fidl_fuchsia_settings::{
AccessibilityProxy, AccessibilitySettings, CaptionFontStyle, CaptionsSettings,
};
pub async fn command(
proxy: AccessibilityProxy,
options: AccessibilityOptions,
) -> Result<String, Error> {
let mut settings = AccessibilitySettings::empty();
settings.audio_description = options.audio_description;
settings.screen_reader = options.screen_reader;
settings.color_inversion = options.color_inversion;
settings.enable_magnification = options.enable_magnification;
settings.color_correction = options.color_correction;
if let Some(caption_settings_enum) = options.caption_options {
let CaptionCommands::CaptionOptions(input) = caption_settings_enum;
let style = input.style;
let mut font_style = CaptionFontStyle::empty();
font_style.family = style.font_family;
font_style.color = style.font_color;
font_style.relative_size = style.relative_size;
font_style.char_edge_style = style.char_edge_style;
let mut captions_settings = CaptionsSettings::empty();
captions_settings.for_media = input.for_media;
captions_settings.for_tts = input.for_tts;
captions_settings.window_color = input.window_color;
captions_settings.background_color = input.background_color;
captions_settings.font_style = Some(font_style);
settings.captions_settings = Some(captions_settings);
}
if settings == AccessibilitySettings::empty() {
// No values set, perform a get instead.
let setting = proxy.watch().await?;
match setting {
Ok(setting_value) => Ok(format!("{:#?}", setting_value)),
Err(err) => Ok(format!("{:#?}", err)),
}
} else {
let mutate_result = proxy.set(settings).await?;
match mutate_result {
Ok(_) => Ok(format!("Successfully set AccessibilitySettings")),
Err(err) => Ok(format!("{:#?}", err)),
}
}
}
|
use rand::prelude::*;
use std::fmt;
/* Number of students to assign */
// const NSTUDENT: usize = 25;
const NSTUDENT: usize = 27;
/* Number of sets to assign to */
const NSET: usize = 13;
/* Number of choices of set per student */
const NCHOICE: usize = 5;
/* Default rank for unclassified sets */
const UNCLASSIFIED_RANK: usize = NSET;
/* Min-max number of students per set */
const NSPS_MIN: usize = 3;
const NSPS_MAX: usize = 5;
/* Target number of students per set */
const NSPS_TARGET: usize = 4;
const A: usize = 0;
const B: usize = 1;
const C: usize = 2;
const D: usize = 3;
const E: usize = 4;
const F: usize = 5;
const G: usize = 6;
const H: usize = 7;
const I: usize = 8;
const J: usize = 9;
const K: usize = 10;
const L: usize = 11;
const M: usize = 12;
/* Return the score (penalty) for a given choice rank.
The lower the rank, the lower the score. */
fn score_for_rank(irank: usize) -> i64 {
return (irank * irank) as i64;
}
/* Return the score (penalty) for a given set size,
given the number of junior and senior students. */
fn score_for_setsize(njs: usize, nss: usize) -> i64 {
if njs == 0 || nss == 0 {
/* Forbid either no junior or senior student in set */
return 100000;
}
/* Total number of student in group */
let ns = njs + nss;
/* Number of student over if group is too small or too large */
let nover;
if ns < NSPS_MIN {
nover = (NSPS_MIN - ns) as i64;
} else if ns > NSPS_MAX {
nover = (ns - NSPS_MAX) as i64;
} else {
nover = 0;
}
/* Add a penalty if a single senior student in set */
let nssk = if nss == 1 { 10 } else { 0 };
/* Delta to nominal group size */
let mut delta = ns as i64 - NSPS_TARGET as i64;
if delta < 0 {
delta = -delta;
}
delta * delta * 2 + nover * nover * 1000 + nssk
}
struct Student {
name: String,
senior: bool,
/* Choices of sets, indices of set, by rank */
choices: [usize; NCHOICE],
/* Rank in choices for each set.
UNCLASSIFIED_RANK for set not in choices. */
ranks: [usize; NSET],
}
struct Classroom {
students: Vec<Student>,
}
#[derive(Eq, PartialEq, Ord, PartialOrd)]
struct SetSelection {
/* Score for this selection, used for ordering */
score: i64,
/* Number of sets selected in this selection */
nsets: usize,
/* Bit-set of selected sets */
selected: [bool; NSET],
}
#[derive(Debug)]
struct Allocation {
/* Score of this allocation */
score: i64,
/* Index to allocated set for each student */
alloc: [usize; NSTUDENT],
}
impl Student {
fn new(name: &str, senior: bool, choices: [usize; NCHOICE]) -> Student {
let mut ranks = [UNCLASSIFIED_RANK; NSET];
for irank in 0..choices.len() {
let iset = choices[irank];
assert!(iset < NSET);
ranks[iset] = irank;
}
Student { name: name.to_string(), senior: senior, choices: choices, ranks: ranks }
}
/* Find the best set according to the set selection */
fn best_set(&self, set_selection: &SetSelection) -> usize {
/* Select the first set in the student choice */
for irank in 0..NCHOICE {
let iset = self.choices[irank];
if set_selection.selected[iset] {
return iset;
}
}
/* Otherwise pick first set selectable */
for iset in 0..NSET {
if set_selection.selected[iset] {
return iset;
}
}
panic!("Should not be here")
}
}
impl fmt::Debug for Student {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Student {{ {:20} {} [",
self.name,
if self.senior { "senior" } else { "junior" })?;
for iset in &self.choices {
write!(f, "{:1} ", (iset + 'A' as usize) as u8 as char)?;
}
write!(f, "] ranks=[")?;
for irank in &self.ranks {
write!(f, "{:2} ", irank)?;
}
write!(f, "] }}")
}
}
impl Classroom {
fn new(students: Vec<Student>) -> Classroom {
Classroom { students: students }
}
fn rand_choices(rng: &mut StdRng) -> [usize; NCHOICE] {
// Random weighting for each set
// const SET_COEFS: [u32; NSET] = [ 100, 30, 30, 30 ];
// const SET_COEFS: [u32; NSET] = [ 100, 100, 80, 80, 80, 80, 60, 60, 60, 40, 40, 40, 40, 30, 30, 30 ];
const SET_COEFS: [u32; NSET] = [ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 ];
let mut ret = [0; NCHOICE];
let mut set_indexes = [0; NSET];
for iset in 0..set_indexes.len() {
set_indexes[iset] = iset;
}
let mut picked_sets = [false; NSET];
assert!(NCHOICE <= NSET); // Otherwise will loop forever
for irank in 0..NCHOICE {
loop {
let iset = *set_indexes.choose_weighted(rng, |is| SET_COEFS[*is]).unwrap();
if !picked_sets[iset] {
ret[irank] = iset;
picked_sets[iset] = true;
break;
}
}
}
ret
}
/* Generate a random classroom, composed of 1/3 junior, 2/3 senior. */
fn rand(rng: &mut StdRng) -> Classroom {
let mut students = Vec::new();
for istd in 0..NSTUDENT {
students.push(Student::new(
&format!("E{:02}", istd),
istd > NSTUDENT / 3,
Classroom::rand_choices(rng)));
}
Classroom { students: students }
}
}
impl fmt::Debug for Classroom {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for (istd, student) in self.students.iter().enumerate() {
writeln!(f, " {:2} - {:?}", istd, student)?;
}
write!(f, "")
}
}
impl SetSelection {
fn new(score: i64, nsets: usize, selected: [bool; NSET]) -> SetSelection {
SetSelection { score: score, nsets: nsets, selected: selected }
}
/* Generate all different set selections, ordered by the sum of the weight of selected set */
fn generate(class: &Classroom, nsets_min: usize, nsets_max: usize) -> Vec<SetSelection> {
assert!(nsets_min <= NSET);
assert!(nsets_max <= NSET);
assert!(nsets_min <= nsets_max);
fn generate(selection: &[bool; NSET], set_scores: &[i64; NSET], start: usize, n: usize, ret: &mut Vec<SetSelection>) {
if n == 0 {
let mut score: i64 = 0;
let mut nsets: usize = 0;
for iset in 0..selection.len() {
if selection[iset] {
score += set_scores[iset];
nsets += 1;
}
}
ret.push(SetSelection::new(score * 100 / nsets as i64, nsets, *selection));
return
}
if start >= NSET {
return
}
let mut selection2 = [false; NSET];
selection2.clone_from_slice(selection);
selection2[start] = true;
generate(&selection2, set_scores, start + 1, n-1, ret);
selection2[start] = false;
generate(&selection2, set_scores, start + 1, n, ret);
}
let mut ret = Vec::new();
let selection = [false; NSET];
let set_scores = Self::scores(class);
println!("Sets scores: {:?}", set_scores);
for nsets in nsets_min..nsets_max+1 {
generate(&selection, &set_scores, 0, nsets, &mut ret);
}
ret.sort();
println!("Generated {} set selections, from {} to {} from {} sets.", ret.len(), nsets_min, nsets_max, NSET);
ret
}
/* Compute score of sets from a Classroom choices */
fn scores(class: &Classroom) -> [i64; NSET] {
let mut ret = [0; NSET];
for iset in 0..NSET {
/* The score of a set is the NSPS_MAX best ranks scores */
let mut best_ranks = Vec::new();
for student in &class.students {
best_ranks.push(student.ranks[iset]);
}
best_ranks.sort();
best_ranks.truncate(NSPS_MAX);
for rank in &best_ranks {
ret[iset] += score_for_rank(*rank);
}
}
ret
}
}
impl fmt::Debug for SetSelection {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut n = 0;
write!(f, "[")?;
for (iset, sel) in self.selected.iter().enumerate() {
if *sel {
write!(f, "{:1} ", (iset + 'A' as usize) as u8 as char)?;
n += 1;
} else {
write!(f, "__ ")?;
}
}
write!(f, "] {} sets, score {}", n, self.score)
}
}
impl Allocation {
fn new(classroom: &Classroom, set_selection: &SetSelection) -> Allocation {
let mut alloc = [999; NSTUDENT];
for istd in 0..NSTUDENT {
alloc[istd] = classroom.students[istd].best_set(set_selection);
}
Allocation { score: Self::score(alloc, classroom, set_selection), alloc: alloc }
}
/* Compute the score of this allocation */
fn score(alloc: [usize; NSTUDENT], classroom: &Classroom, set_selection: &SetSelection) -> i64 {
let mut nssps = [0; NSET];
let mut njsps = [0; NSET];
let mut rank_score = 0;
for istd in 0..NSTUDENT {
let student = &classroom.students[istd];
let iset = alloc[istd];
if student.senior {
nssps[iset] += 1;
} else {
njsps[iset] += 1;
}
rank_score += score_for_rank(student.ranks[iset]);
}
let mut set_score = 0;
for iset in 0..NSET {
if set_selection.selected[iset] {
set_score += score_for_setsize(njsps[iset], nssps[iset]);
}
}
rank_score + set_score
}
/* Move one student of this allocation from one set to another one,
but only if the move decrease the score.
Return true if the allocation has been modified. */
fn move_one(&mut self, classroom: &Classroom, set_selection: &SetSelection, rng: &mut StdRng, verbose: bool) -> bool {
let mut alloc2 = [0; NSTUDENT];
alloc2.clone_from_slice(&self.alloc);
let istd = rng.gen_range(0, NSTUDENT);
let old_iset = alloc2[istd];
let mut new_iset;
loop {
new_iset = rng.gen_range(0, NSET);
if new_iset != old_iset && set_selection.selected[new_iset] {
break;
}
}
alloc2[istd] = new_iset;
let new_score = Self::score(alloc2, classroom, set_selection);
if new_score >= self.score {
// Not better
false
} else {
// Better
let student = &classroom.students[istd];
if verbose {
println!("MOVED student {} from set {} (rank {}) to {} (rank {}), score {} > {}",
istd, old_iset, student.ranks[old_iset], new_iset, student.ranks[new_iset],
self.score, new_score);
}
self.alloc.clone_from_slice(&alloc2);
self.score = new_score;
true
}
}
/* Swap two students sets of this allocation,
but only if the swap decrease the score.
Return true if the allocation has been modified. */
fn swap_two(&mut self, classroom: &Classroom, set_selection: &SetSelection, rng: &mut StdRng, verbose: bool) -> bool {
let mut alloc2 = [0; NSTUDENT];
alloc2.clone_from_slice(&self.alloc);
let istd1 = rng.gen_range(0, NSTUDENT);
let istd2 = rng.gen_range(0, NSTUDENT);
let old_iset1 = alloc2[istd1];
let old_iset2 = alloc2[istd2];
alloc2[istd1] = alloc2[istd2];
alloc2[istd2] = old_iset1;
let new_score = Self::score(alloc2, classroom, set_selection);
if new_score >= self.score {
// Not better
false
} else {
// Better
if verbose {
let student1 = &classroom.students[istd1];
let student2 = &classroom.students[istd2];
println!("SWAPPED student {} from set {} (rank {}) to set {} (rank {})",
istd1, old_iset1, student1.ranks[old_iset1], alloc2[istd1], student1.ranks[alloc2[istd1]]);
println!(" with student {} from set {} (rank {}) to set {} (rank {}), score {} > {}",
istd2, old_iset2, student2.ranks[old_iset2], alloc2[istd2], student2.ranks[alloc2[istd2]],
self.score, new_score);
}
self.alloc.clone_from_slice(&alloc2);
self.score = new_score;
true
}
}
fn debug(&self, classroom: &Classroom) {
println!("===========================================================");
println!("{:?}", self);
let mut nssps = [0; NSET];
let mut njsps = [0; NSET];
let mut nrank = [0; NCHOICE];
for istd in 0..NSTUDENT {
let student = &classroom.students[istd];
let iset = self.alloc[istd];
if student.senior {
nssps[iset] += 1;
} else {
njsps[iset] += 1;
}
let rank = student.ranks[iset];
println!(" {:?} - Set {:2} (choice {:2}, score {:4})",
student, (iset + 'A' as usize) as u8 as char, rank + 1, score_for_rank(rank));
if rank < NCHOICE {
nrank[rank] += 1;
}
}
println!("-----------------------------------------------------------");
for iset in 0..NSET {
let ntot = njsps[iset] + nssps[iset];
if ntot > 0 {
println!(" Set {:2} - {} students ({} junior, {} senior), score={}",
(iset + 'A' as usize) as u8 as char, ntot, njsps[iset], nssps[iset],
score_for_setsize(njsps[iset], nssps[iset]));
}
}
println!("-----------------------------------------------------------");
for irank in 0..NCHOICE {
println!("Choice {:1} - {:2} students",
irank + 1, nrank[irank]);
}
println!("===========================================================");
}
}
/* Search for the best allocation of a given set selection,
using depth as the search limit.
Return the best allocation found, if any. */
fn find_best_alloc(classroom: &Classroom, set_selection: &SetSelection, rng: &mut StdRng, depth: usize) -> Option<Allocation> {
let mut best_alloc: Option<Allocation> = None;
/* Loop depth time, using a new base allocation as a starting point. */
for _i in 0..depth {
let mut alloc = Allocation::new(&classroom, &set_selection);
let mut stuck_counter = 0;
loop {
let mut modified = false;
if alloc.move_one(classroom, set_selection, rng, false) { modified = true }
if alloc.swap_two(classroom, set_selection, rng, false) { modified = true }
if !modified { stuck_counter += 1 } else { stuck_counter = 0 }
/* After a while w/o any improvement, give up. */
if stuck_counter > depth * 10 { break }
}
if best_alloc.is_none() || alloc.score < best_alloc.as_ref().unwrap().score {
// println!("Found better allocation, score {}", alloc.score);
// alloc.debug(&classroom);
best_alloc = Some(alloc);
}
}
best_alloc
}
fn main() {
/* Deterministic random generator for Monte-Carlo */
// Best is 1, 50 - but one choice is 4th
// Best is 2, 53
let mut seed = [0; 32]; seed[0] = 4;
let mut rng: StdRng = SeedableRng::from_seed(seed);
/* Create a classroom */
/* let classroom1 = Classroom::new(vec![
Student::new("Duprez Nina", true , [ D, I, L, J, F ]),
Student::new("Allaire Naรฏla", true, [ G, A, K, H, C ]),
Student::new("Suaudeau Anaรฏs", true, [ B, A, L, K, C ]),
Student::new("Rouleau Michka", false, [ I, L, F, J, D ]),
Student::new("Rolland Marie", true, [ I, F, D, C, J ]),
Student::new("Girard Antoine", false, [ L, F, D, E, K ]),
Student::new("Bethys Jodie", false, [ L, F, E, D, J ]),
Student::new("Hacques Malou", true, [ D, E, B, F, K ]),
Student::new("Chataigner Sรถren", false, [ I, E, A, K, C ]),
Student::new("Massons Estelle", false, [ I, G, F, B, L ]),
Student::new("Henni Naomy", true, [ L, F, E, J, C ]),
Student::new("Ragnaud Fybie", false, [ E, L, D, A, F ]),
Student::new("Foucher Cรฉlestin", true, [ L, B, A, C, E ]),
Student::new("Brimaud Florian", false, [ F, J, D, I, L ]),
Student::new("Touzot Mattรฉo", false, [ B, F, L, G, A ]),
Student::new("Das Dores Gwendoline", false, [ F, J, L, E, I ]),
Student::new("Brunel Nina", true, [ D, L, H, F, E ]),
Student::new("Desfossรฉ Angรจle", true, [ B, D, G, I, L ]),
Student::new("Guรฉrin Rudy", true, [ D, I, L, J, F ]),
Student::new("Grellaud Camille", true, [ D, H, B, F, C ]),
Student::new("Savagnac Kassandra", false, [ I, J, K, L, F ]),
Student::new("Guillou Maรซva", true, [ D, A, L, B, F ]),
Student::new("Di Nallo Manon", false, [ D, L, J, I, E ]),
Student::new("Delval Epona", true, [ F, C, L, E, J ]),
Student::new("Wagner Pierre", false, [ B, L, F, I, A ]),
]);*/
/* Create a classroom */
let classroom2 = Classroom::new(vec![
Student::new("epona delval", true, [ C, J, I, B, F ]),
Student::new("kassandra savagnac", false, [ J, F, D, L, A ]),
Student::new("soren chateigner", false, [ F, C, I, B, J ]),
Student::new("camille grellaud", true, [ F, J, L, C, A ]),
Student::new("matteo tuzo", false, [ C, F, D, J, L ]),
Student::new("fybie ragnaud", false, [ C, D, J, I, A ]),
Student::new("jodie bethys", false, [ C, J, D, I, B ]),
Student::new("antoine girard", false, [ I, D, F, J, B ]),
Student::new("gwendoline das dores", false, [ J, D, B, L, C ]),
Student::new("florian bremaud", false, [ J, D, L, C, I ]),
Student::new("nina brunel", true, [ D, J, F, A, B ]),
Student::new("naomy henny", true, [ A, J, L, C, B ]),
Student::new("estelle masson", false, [ J, L, C, F, B ]),
Student::new("malou hacques", true, [ J, C, F, B, I ]),
Student::new("manon di nalo", false, [ J, C, F, L, I ]),
Student::new("landric rusquet", false, [ J, L, A, B, C ]),
Student::new("pierre wagner", false, [ J, L, F, D, C ]),
]);
let classroom3 = Classroom::new(vec![
Student::new("Logan", false, [ I,K,B,L,C ]),
Student::new("Juliette", false, [ E,L,K,I,C ]),
Student::new("Soren", true, [ I,L,M,C,A ]),
Student::new("Maรฏly", false, [ L,I,K,E,J ]),
Student::new("Jodie", true, [ I,D,C,L,E ]),
Student::new("Louane", false, [ I,A,C,E,L ]),
Student::new("Malou", true, [ I,K,J,G,F ]),
Student::new("Anaรซlle", false, [ L,K,F,J,I ]),
Student::new("Camille", true, [ I,H,K,L,C ]),
Student::new("Antoine", true, [ I,H,L,K,E ]),
Student::new("Naomy", true, [ I,K,L,C,E ]),
Student::new("Epona", true, [ I,C,D,M,E ]),
Student::new("Nina B", true, [ M,L,I,K,B ]),
Student::new("Ethan", false, [ L,I,F,C,K ]),
Student::new("Manon", true, [ L,I,E,K,H ]),
Student::new("Elรฉrose", false, [ H,M,G,F,D ]),
Student::new("Quentin", false, [ A,B,C,E,G ]),
Student::new("Dorian", false, [ M,L,G,A,K ]),
Student::new("Chloรฉ", false, [ C,I,L,E,J ]),
Student::new("Flavien", false, [ C,G,H,K,I ]),
Student::new("Nawel", false, [ E,I,H,C,L ]),
Student::new("Maxime", false, [ C,E,I,L,H ]),
Student::new("Jeanne", false, [ I,C,L,H,B ]),
Student::new("Estelle", true, [ I,F,D,G,K ]),
Student::new("Rose", false, [ D,F,M,K,J ]),
Student::new("Matisse", false, [ C,A,K,G,D ]),
Student::new("Mattรฉo", true, [ D,A,G,F,M ]),
]);
// let classroom_rand = Classroom::rand(&mut rng);
let classroom = classroom3;
println!("Our classroom is:\n{:?}", &classroom);
/* Generate all set selections */
let nsets_min = NSTUDENT / NSPS_MAX;
let nsets_max = NSTUDENT / NSPS_MIN;
let mut set_selections = SetSelection::generate(&classroom, nsets_min, nsets_max);
set_selections.truncate(1000);
let mut depth = 1;
let mut curr_set_selections: Vec<&SetSelection> = Vec::new();
for set_selection in &set_selections {
curr_set_selections.push(set_selection);
}
let mut best_score = 999999;
let mut stuck_counter = 0;
let mut best_alloc: Option<Allocation> = None;
loop {
println!("Scanning {} set selections, depth {}, best score {}, stuck counter {}...",
curr_set_selections.len(),
depth, best_score, stuck_counter);
let mut next_set_selections: Vec<&SetSelection> = Vec::new();
let mut next_best_score = best_score;
for set_selection in &curr_set_selections {
// println!("{:?}", set_selection);
let alloc = find_best_alloc(&classroom, set_selection, &mut rng, depth);
match &alloc {
None => {},
Some(dalloc) => {
let score = dalloc.score;
if score <= best_score * 2 {
next_set_selections.push(set_selection);
}
if score < next_best_score {
println!("Found better allocation, score {}", score);
best_alloc = alloc;
next_best_score = score;
}
}
}
}
stuck_counter = if best_score == next_best_score { stuck_counter + 1 } else { 0 };
best_score = next_best_score;
curr_set_selections = next_set_selections;
depth = depth + 1;
if stuck_counter + depth > 30 || curr_set_selections.is_empty() { break }
}
match best_alloc {
None => println!("No allocation found."),
Some(alloc) => {
println!("Best allocation found:");
alloc.debug(&classroom);
}
}
}
|
use crate::impl_pnext;
use crate::prelude::*;
use std::os::raw::c_void;
use std::ptr;
#[repr(C)]
#[derive(Debug)]
pub struct VkDescriptorSetLayoutCreateInfo {
pub sType: VkStructureType,
pub pNext: *const c_void,
pub flags: VkDescriptorSetLayoutCreateFlagBits,
pub bindingCount: u32,
pub pBindings: *const VkDescriptorSetLayoutBinding,
}
impl VkDescriptorSetLayoutCreateInfo {
pub fn new<T>(flags: T, bindings: &[VkDescriptorSetLayoutBinding]) -> Self
where
T: Into<VkDescriptorSetLayoutCreateFlagBits>,
{
VkDescriptorSetLayoutCreateInfo {
sType: VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
pNext: ptr::null(),
flags: flags.into(),
bindingCount: bindings.len() as u32,
pBindings: bindings.as_ptr(),
}
}
}
impl_pnext!(
VkDescriptorSetLayoutCreateInfo,
VkDescriptorSetLayoutBindingFlagsCreateInfoEXT
);
|
use diesel::prelude::*;
use super::Context;
use super::QueryRoot;
use crate::graphql_schema::resolver::Team;
impl QueryRoot {
pub(crate) fn teams_impl(context: &Context) -> Vec<Team> {
use crate::schema::teams::dsl::*;
let connection = context.db.get().unwrap();
teams
.limit(100)
.load::<Team>(&connection)
.expect("Error loading teams")
}
}
|
#[cfg(target_arch = "x86")]
use core::arch::aarch64::*;
use core::mem::transmute;
// ๅ่: https://github.com/noloader/AES-Intrinsics/blob/master/clmul-arm.c
pub unsafe fn pmull(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
// Low
let a: poly64_t = transmute(vgetq_lane_u64(vreinterpretq_u64_u8(a), 0));
let b: poly64_t = transmute(vgetq_lane_u64(vreinterpretq_u64_u8(b), 0));
transmute(vmull_p64(a, b))
}
pub unsafe fn pmull2(a: uint8x16_t, b: uint8x16_t) -> uint8x16_t {
// High
let a: poly64_t = transmute(vgetq_lane_u64(vreinterpretq_u64_u8(a), 1));
let b: poly64_t = transmute(vgetq_lane_u64(vreinterpretq_u64_u8(b), 1));
transmute(vmull_p64(a, b))
}
// Perform the multiplication and reduction in GF(2^128)
unsafe fn gf_mul(h: uint8x16_t, x: &mut [u8; 16]) {
// NOTE: ๅจไผ ๅ
ฅไนๅ ็กฎไฟ h ็็ซฏๅบใ
let a8 = h;
// ่ฝฌๆข็ซฏๅบ๏ผvrbitq_u8๏ผ
x.reverse();
// vld1q_u8
let b8 = transmute(x.clone());
// polynomial multiply
let z = vdupq_n_u8(0);
let mut r0 = pmull(a8, b8);
let mut r1 = pmull2(a8, b8);
let mut t0 = vextq_u8(b8, b8, 8);
let mut t1 = pmull(a8, t0);
t0 = pmull2(a8, t0);
t0 = veorq_u8(t0, t1);
t1 = vextq_u8(z, t0, 8);
r0 = veorq_u8(r0, t1);
t1 = vextq_u8(t0, z, 8);
r1 = veorq_u8(r1, t1);
// polynomial reduction
// https://developer.arm.com/architectures/instruction-sets/simd-isas/neon/intrinsics?search=vdupq_n_u64
// let p = vreinterpretq_u8_u64(vdupq_n_u64(0x0000000000000087));
let p = transmute(vdupq_n_u64(0x0000000000000087));
t0 = pmull2(r1, p);
t1 = vextq_u8(t0, z, 8);
r1 = veorq_u8(r1, t1);
t1 = vextq_u8(z, t0, 8);
r0 = veorq_u8(r0, t1);
t0 = pmull(r1, p);
let c8 = veorq_u8(r0, t0);
// vrbitq_u8
// vst1q_u8
// https://developer.arm.com/architectures/instruction-sets/simd-isas/neon/intrinsics?search=vrbitq_u8
let r: [u8; 16] = transmute(c8);
x[ 0] = r[15];
x[ 1] = r[14];
x[ 2] = r[13];
x[ 3] = r[12];
x[ 4] = r[11];
x[ 5] = r[10];
x[ 6] = r[ 9];
x[ 7] = r[ 8];
x[ 8] = r[ 7];
x[ 9] = r[ 6];
x[10] = r[ 5];
x[11] = r[ 4];
x[12] = r[ 3];
x[13] = r[ 2];
x[14] = r[ 1];
x[15] = r[ 0];
}
#[derive(Debug, Clone)]
pub struct GHash {
h: uint8x16_t,
}
impl GHash {
pub const BLOCK_LEN: usize = 16;
pub fn new(h: &[u8; Self::BLOCK_LEN]) -> Self {
let mut h = h.clone();
h.reverse();
Self { h: transmute(h) }
}
pub fn ghash(&self, data: &mut [u8; Self::BLOCK_LEN]) {
gf_mul(self.h, data)
}
} |
// Copyright 2018-2021 Parity Technologies (UK) Ltd.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#![cfg_attr(not(feature = "std"), no_std)]
/// Evaluate `$x:expr` and if not true return `Err($y:expr)`.
///
/// Used as `ensure!(expression_to_ensure, expression_to_return_on_false)`.
macro_rules! ensure {
( $condition:expr, $error:expr $(,)? ) => {{
if !$condition {
return ::core::result::Result::Err(::core::convert::Into::into($error))
}
}};
}
pub use self::entity::Contract;
#[metis_lang::contract]
mod entity {
#[allow(unused_imports)]
use ink_prelude::{
collections::BTreeMap,
format,
string::String,
vec::Vec,
};
#[allow(unused_imports)]
use ink_storage::{
collections::{
HashMap as StorageHashMap,
Vec as StorageVec,
},
traits::{
PackedLayout,
SpreadLayout,
},
};
#[allow(unused_imports)]
use metis_lang::{
import,
metis,
};
#[allow(unused_imports)]
use metis_ownable as ownable;
#[allow(unused_imports)]
use trait_erc1155::{
consts::MAGIC_VALUE_RECEIVED,
types::{
Error,
Result,
TokenId,
},
IERC1155Metadata,
IErc1155,
IErc1155TokenReceiver,
};
/// Event emitted when Owner AccountId Transferred
#[ink(event)]
#[metis(ownable)]
pub struct OwnershipTransferred {
/// previous owner account id
#[ink(topic)]
previous_owner: Option<AccountId>,
/// new owner account id
#[ink(topic)]
new_owner: Option<AccountId>,
}
/// Indicate that a token transfer has occured.
///
/// This must be emitted even if a zero value transfer occurs.
/// @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
///
/// The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
/// The `_from` argument MUST be the address of the holder whose balance is decreased.
/// The `_to` argument MUST be the address of the recipient whose balance is increased.
/// The `_id` argument MUST be the token type being transferred.
/// The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
/// When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
/// When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
#[ink(event)]
pub struct TransferSingle {
#[ink(topic)]
operator: Option<AccountId>,
#[ink(topic)]
from: Option<AccountId>,
#[ink(topic)]
to: Option<AccountId>,
token_id: TokenId,
value: Balance,
}
/// @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled).
#[ink(event)]
pub struct ApprovalForAll {
#[ink(topic)]
owner: AccountId,
#[ink(topic)]
operator: AccountId,
approved: bool,
}
/// Represents an (Owner, Operator) pair, in which the operator is allowed to spend funds on
/// behalf of the operator.
#[derive(
Copy,
Clone,
Debug,
Ord,
PartialOrd,
Eq,
PartialEq,
PackedLayout,
SpreadLayout,
scale::Encode,
scale::Decode,
)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
struct Approval {
owner: AccountId,
operator: AccountId,
}
/// An ERC-1155 contract.
#[ink(storage)]
#[import(ownable)]
pub struct Contract {
/// Tracks the balances of accounts across the different tokens that they might be holding.
balances: BTreeMap<(AccountId, TokenId), Balance>,
/// Which accounts (called operators) have been approved to spend funds on behalf of an owner.
approvals: BTreeMap<Approval, ()>,
/// A unique identifier for the tokens which have been minted (and are therefore supported) by this contract.
token_id_nonce: TokenId,
/// Ownable data
ownable: ownable::Data<Contract>,
/// The accounts who creates
creators: StorageHashMap<TokenId, AccountId>,
/// token metadata uri
token_uris: StorageHashMap<TokenId, Option<String>>,
/// token metadata baseuri
base_uri: Option<String>,
}
impl Contract {
/// Initialize a default instance of this ERC-1155 implementation.
#[ink(constructor)]
pub fn new(_base_uri: Option<String>) -> Self {
let mut instance = Self {
balances: Default::default(),
approvals: Default::default(),
token_id_nonce: Default::default(),
ownable: ownable::Data::new(),
creators: StorageHashMap::new(),
token_uris: StorageHashMap::new(),
base_uri: _base_uri,
};
// init metis ownable module
ownable::Impl::init(&mut instance);
instance
}
/// Create the initial supply for a token.
///
/// The initial supply will be provided to the caller (a.k.a the minter), and the
/// `token_id` will be assigned by the smart contract.
///
/// Note that as implemented anyone can create tokens. If you were to deploy this to a
/// production environment you'd probably want to lock down the addresses that are allowed
/// to create tokens.
#[ink(message)]
pub fn create(
&mut self,
_initial_supply: Balance,
_metadata_uri: Option<String>,
) -> TokenId {
let caller = self.env().caller();
// Given that TokenId is a `u128` the likelihood of this overflowing is pretty slim.
self.token_id_nonce += 1;
// Add balance
if _initial_supply > 0 {
self.balances
.insert((caller, self.token_id_nonce), _initial_supply);
}
// Set creator
self.creators.insert(self.token_id_nonce, caller);
// Set metadata
self.token_uris.insert(self.token_id_nonce, _metadata_uri);
// Emit transfer event but with mint semantics
self.env().emit_event(TransferSingle {
operator: Some(caller),
from: None,
to: if _initial_supply == 0 {
None
} else {
Some(caller)
},
token_id: self.token_id_nonce,
value: _initial_supply,
});
self.token_id_nonce
}
/// Mint a `value` amount of `token_id` tokens.
///
/// It is assumed that the token has already been `create`-ed. The newly minted supply will
/// be assigned to the caller (a.k.a the minter).
///
/// Note that as implemented anyone can mint tokens. If you were to deploy this to a
/// production environment you'd probably want to lock down the addresses that are allowed
/// to mint tokens.
#[ink(message)]
pub fn mint(&mut self, token_id: TokenId, value: Balance) -> Result<()> {
ensure!(token_id <= self.token_id_nonce, Error::UnexistentToken);
let caller = self.env().caller();
let creator = self.creators.get(&token_id);
ensure!(creator.clone().unwrap() == &caller, Error::NotTokenCreator);
ensure!(value > 0, Error::ZeroAmountMint);
self.balances.insert((caller, token_id), value);
// Emit transfer event but with mint semantics
self.env().emit_event(TransferSingle {
operator: Some(caller),
from: None,
to: Some(caller),
token_id,
value,
});
Ok(())
}
// Ownable messages
#[ink(message)]
pub fn get_ownership(&self) -> Option<AccountId> {
*ownable::Impl::owner(self)
}
#[ink(message)]
pub fn renounce_ownership(&mut self) {
ownable::Impl::renounce_ownership(self)
}
#[ink(message)]
pub fn transfer_ownership(&mut self, new_owner: AccountId) {
ownable::Impl::transfer_ownership(self, &new_owner)
}
#[ink(message)]
pub fn set_base_uri(&mut self, new_base_uri: Option<String>) -> Result<()> {
let caller = self.env().caller();
ensure!(
&self.get_ownership().clone().unwrap() == &caller,
Error::NotContractOwner
);
self.base_uri = new_base_uri;
Ok(())
}
// ------------------------------ Private Methods ------------------------------
/// get token uri
fn _get_token_uri(&self, token_id: TokenId) -> Option<String> {
self.token_uris.get(&token_id).unwrap_or(&None).clone()
}
// Helper function for performing single token transfers.
//
// Should not be used directly since it's missing certain checks which are important to the
// ERC-1155 standard (it is expected that the caller has already performed these).
fn _perform_transfer(
&mut self,
from: AccountId,
to: AccountId,
token_id: TokenId,
value: Balance,
) {
self.balances
.entry((from, token_id))
.and_modify(|b| *b -= value);
self.balances
.entry((to, token_id))
.and_modify(|b| *b += value)
.or_insert(value);
let caller = self.env().caller();
self.env().emit_event(TransferSingle {
operator: Some(caller),
from: Some(from),
to: Some(from),
token_id,
value,
});
}
// Check if the address at `to` is a smart contract which accepts ERC-1155 token transfers.
//
// If they're a smart contract which **doesn't** accept tokens transfers this call will
// revert. Otherwise we risk locking user funds at in that contract with no chance of
// recovery.
#[cfg_attr(test, allow(unused_variables))]
fn _transfer_acceptance_check(
&mut self,
caller: AccountId,
from: AccountId,
to: AccountId,
token_id: TokenId,
value: Balance,
data: Vec<u8>,
) {
// This is disabled during tests due to the use of `eval_contract()` not being
// supported (tests end up panicking).
#[cfg(not(test))]
{
use ink_env::call::{
build_call,
utils::ReturnType,
ExecutionInput,
Selector,
};
// If our recipient is a smart contract we need to see if they accept or
// reject this transfer. If they reject it we need to revert the call.
let params = build_call::<ink_env::DefaultEnvironment>()
.callee(to)
.gas_limit(5000)
.exec_input(
ExecutionInput::new(Selector::new(MAGIC_VALUE_RECEIVED))
.push_arg(caller)
.push_arg(from)
.push_arg(token_id)
.push_arg(value)
.push_arg(data),
)
.returns::<ReturnType<Vec<u8>>>()
.params();
match ink_env::eval_contract(¶ms) {
Ok(v) => {
ink_env::debug_println!(
"Received return value \"{:?}\" from contract {:?}",
v,
from
);
assert_eq!(
v,
&MAGIC_VALUE_RECEIVED[..],
"The recipient contract at {:?} does not accept token transfers.\n
Expected: {:?}, Got {:?}", to, MAGIC_VALUE_RECEIVED, v
)
}
Err(e) => {
match e {
ink_env::Error::CodeNotFound
| ink_env::Error::NotCallable => {
// Our recipient wasn't a smart contract, so there's nothing more for
// us to do
ink_env::debug_println!("Recipient at {:?} from is not a smart contract ({:?})", from, e);
}
_ => {
// We got some sort of error from the call to our recipient smart
// contract, and as such we must revert this call
let msg = ink_prelude::format!(
"Got error \"{:?}\" while trying to call {:?}",
e,
from
);
ink_env::debug_println!("{}", &msg);
panic!("{}", &msg)
}
}
}
}
}
}
}
/// ERC 1155 basic implementation
impl IErc1155 for Contract {
#[ink(message)]
fn safe_transfer_from(
&mut self,
from: AccountId,
to: AccountId,
token_id: TokenId,
value: Balance,
data: Vec<u8>,
) -> Result<()> {
let caller = self.env().caller();
if caller != from {
ensure!(self.is_approved_for_all(from, caller), Error::NotApproved);
}
ensure!(to != AccountId::default(), Error::ZeroAddressTransfer);
let balance = self.balance_of(from, token_id);
ensure!(balance >= value, Error::InsufficientBalance);
self._perform_transfer(from, to, token_id, value);
self._transfer_acceptance_check(caller, from, to, token_id, value, data);
Ok(())
}
#[ink(message)]
fn safe_batch_transfer_from(
&mut self,
from: AccountId,
to: AccountId,
token_ids: Vec<TokenId>,
values: Vec<Balance>,
data: Vec<u8>,
) -> Result<()> {
let caller = self.env().caller();
if caller != from {
ensure!(self.is_approved_for_all(from, caller), Error::NotApproved);
}
ensure!(to != AccountId::default(), Error::ZeroAddressTransfer);
ensure!(!token_ids.is_empty(), Error::BatchTransferMismatch);
ensure!(
token_ids.len() == values.len(),
Error::BatchTransferMismatch,
);
let transfers = token_ids.iter().zip(values.iter());
for (&id, &v) in transfers.clone() {
let balance = self.balance_of(from, id);
ensure!(balance >= v, Error::InsufficientBalance);
}
for (&id, &v) in transfers {
self._perform_transfer(from, to, id, v);
}
// Can use the any token ID/value here, we really just care about knowing if `to` is a
// smart contract which accepts transfers
self._transfer_acceptance_check(
caller,
from,
to,
token_ids[0],
values[0],
data,
);
Ok(())
}
#[ink(message)]
fn balance_of(&self, owner: AccountId, token_id: TokenId) -> Balance {
*self.balances.get(&(owner, token_id)).unwrap_or(&0)
}
#[ink(message)]
fn balance_of_batch(
&self,
owners: Vec<AccountId>,
token_ids: Vec<TokenId>,
) -> Vec<Balance> {
let mut output = Vec::new();
for o in &owners {
for t in &token_ids {
let amount = self.balance_of(*o, *t);
output.push(amount);
}
}
output
}
#[ink(message)]
fn set_approval_for_all(
&mut self,
operator: AccountId,
approved: bool,
) -> Result<()> {
let caller = self.env().caller();
ensure!(operator != caller, Error::SelfApproval);
let approval = Approval {
owner: caller,
operator,
};
if approved {
self.approvals.insert(approval, ());
} else {
self.approvals.remove(&approval);
}
self.env().emit_event(ApprovalForAll {
owner: approval.owner,
operator,
approved,
});
Ok(())
}
#[ink(message)]
fn is_approved_for_all(&self, owner: AccountId, operator: AccountId) -> bool {
self.approvals.get(&Approval { owner, operator }).is_some()
}
}
impl IERC1155Metadata for Contract {
/// @notice A distinct Uniform Resource Identifier (URI) for a given token.
/// @dev URIs are defined in RFC 3986.
/// The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
#[ink(message)]
fn uri(&self, token_id: TokenId) -> Option<String> {
let token_uri = self._get_token_uri(token_id);
// return uri
if self.base_uri.is_none() {
token_uri
} else if token_uri.is_some() {
Some(format!(
"{0}{1}",
&self.base_uri.clone().unwrap(),
&token_uri.clone().unwrap()
))
} else {
None
}
}
}
impl IErc1155TokenReceiver for Contract {
#[ink(message, selector = "0xF23A6E61")]
fn on_received(
&mut self,
_operator: AccountId,
_from: AccountId,
_token_id: TokenId,
_value: Balance,
_data: Vec<u8>,
) -> Vec<u8> {
// The ERC-1155 standard dictates that if a contract does not accept token transfers
// directly to the contract, then the contract must revert.
//
// This prevents a user from unintentionally transferring tokens to a smart contract
// and getting their funds stuck without any sort of recovery mechanism.
//
// Note that the choice of whether or not to accept tokens is implementation specific,
// and we've decided to not accept them in this implementation.
unimplemented!("This smart contract does not accept token transfer.")
}
#[ink(message, selector = "0xBC197C81")]
fn on_batch_received(
&mut self,
_operator: AccountId,
_from: AccountId,
_token_ids: Vec<TokenId>,
_values: Vec<Balance>,
_data: Vec<u8>,
) -> Vec<u8> {
// The ERC-1155 standard dictates that if a contract does not accept token transfers
// directly to the contract, then the contract must revert.
//
// This prevents a user from unintentionally transferring tokens to a smart contract
// and getting their funds stuck without any sort of recovery mechanism.
//
// Note that the choice of whether or not to accept tokens is implementation specific,
// and we've decided to not accept them in this implementation.
unimplemented!("This smart contract does not accept batch token transfers.")
}
}
/// Unit tests.
#[cfg(test)]
mod tests {
/// Imports all the definitions from the outer scope so we can use them here.
use super::*;
use crate::entity::Contract;
use ink_lang as ink;
#[cfg(feature = "ink-experimental-engine")]
fn set_sender(sender: AccountId) {
ink_env::test::set_caller::<Environment>(sender);
}
#[cfg(not(feature = "ink-experimental-engine"))]
fn set_sender(sender: AccountId) {
const WALLET: [u8; 32] = [7; 32];
ink_env::test::push_execution_context::<Environment>(
sender,
WALLET.into(),
1000000,
1000000,
ink_env::test::CallData::new(ink_env::call::Selector::new([0x00; 4])), /* dummy */
);
}
#[cfg(feature = "ink-experimental-engine")]
fn default_accounts() -> ink_env::test::DefaultAccounts<Environment> {
ink_env::test::default_accounts::<Environment>()
}
#[cfg(not(feature = "ink-experimental-engine"))]
fn default_accounts() -> ink_env::test::DefaultAccounts<Environment> {
ink_env::test::default_accounts::<Environment>()
.expect("off-chain environment should have been initialized already")
}
fn alice() -> AccountId {
default_accounts().alice
}
fn bob() -> AccountId {
default_accounts().bob
}
fn charlie() -> AccountId {
default_accounts().charlie
}
fn init_contract() -> Contract {
let mut erc = Contract::new(Option::default());
erc.balances.insert((alice(), 1), 10);
erc.balances.insert((alice(), 2), 20);
erc.balances.insert((bob(), 1), 10);
erc
}
#[ink::test]
fn can_get_correct_balance_of() {
let erc = init_contract();
assert_eq!(erc.balance_of(alice(), 1), 10);
assert_eq!(erc.balance_of(alice(), 2), 20);
assert_eq!(erc.balance_of(alice(), 3), 0);
assert_eq!(erc.balance_of(bob(), 2), 0);
}
#[ink::test]
fn can_get_correct_batch_balance_of() {
let erc = init_contract();
assert_eq!(
erc.balance_of_batch(vec![alice()], vec![1, 2, 3]),
vec![10, 20, 0]
);
assert_eq!(
erc.balance_of_batch(vec![alice(), bob()], vec![1]),
vec![10, 10]
);
assert_eq!(
erc.balance_of_batch(vec![alice(), bob(), charlie()], vec![1, 2]),
vec![10, 20, 10, 0, 0, 0]
);
}
#[ink::test]
fn can_send_tokens_between_accounts() {
let mut erc = init_contract();
assert!(erc.safe_transfer_from(alice(), bob(), 1, 5, vec![]).is_ok());
assert_eq!(erc.balance_of(alice(), 1), 5);
assert_eq!(erc.balance_of(bob(), 1), 15);
assert!(erc.safe_transfer_from(alice(), bob(), 2, 5, vec![]).is_ok());
assert_eq!(erc.balance_of(alice(), 2), 15);
assert_eq!(erc.balance_of(bob(), 2), 5);
}
#[ink::test]
fn sending_too_many_tokens_fails() {
let mut erc = init_contract();
let res = erc.safe_transfer_from(alice(), bob(), 1, 99, vec![]);
assert_eq!(res.unwrap_err(), Error::InsufficientBalance);
}
#[ink::test]
fn sending_tokens_to_zero_address_fails() {
let burn: AccountId = [0; 32].into();
let mut erc = init_contract();
let res = erc.safe_transfer_from(alice(), burn, 1, 10, vec![]);
assert_eq!(res.unwrap_err(), Error::ZeroAddressTransfer);
}
#[ink::test]
fn can_send_batch_tokens() {
let mut erc = init_contract();
assert!(erc
.safe_batch_transfer_from(alice(), bob(), vec![1, 2], vec![5, 10], vec![])
.is_ok());
let balances = erc.balance_of_batch(vec![alice(), bob()], vec![1, 2]);
assert_eq!(balances, vec![5, 10, 15, 10])
}
#[ink::test]
fn rejects_batch_if_lengths_dont_match() {
let mut erc = init_contract();
let res = erc.safe_batch_transfer_from(
alice(),
bob(),
vec![1, 2, 3],
vec![5],
vec![],
);
assert_eq!(res.unwrap_err(), Error::BatchTransferMismatch);
}
#[ink::test]
fn batch_transfers_fail_if_len_is_zero() {
let mut erc = init_contract();
let res =
erc.safe_batch_transfer_from(alice(), bob(), vec![], vec![], vec![]);
assert_eq!(res.unwrap_err(), Error::BatchTransferMismatch);
}
#[ink::test]
fn operator_can_send_tokens() {
let mut erc = init_contract();
let owner = alice();
let operator = bob();
set_sender(owner);
assert!(erc.set_approval_for_all(operator, true).is_ok());
set_sender(operator);
assert!(erc
.safe_transfer_from(owner, charlie(), 1, 5, vec![])
.is_ok());
assert_eq!(erc.balance_of(alice(), 1), 5);
assert_eq!(erc.balance_of(charlie(), 1), 5);
}
#[ink::test]
fn approvals_work() {
let mut erc = init_contract();
let owner = alice();
let operator = bob();
let another_operator = charlie();
// Note: All of these tests are from the context of the owner who is either allowing or
// disallowing an operator to control their funds.
set_sender(owner);
assert!(erc.is_approved_for_all(owner, operator) == false);
assert!(erc.set_approval_for_all(operator, true).is_ok());
assert!(erc.is_approved_for_all(owner, operator));
assert!(erc.set_approval_for_all(another_operator, true).is_ok());
assert!(erc.is_approved_for_all(owner, another_operator));
assert!(erc.set_approval_for_all(operator, false).is_ok());
assert!(erc.is_approved_for_all(owner, operator) == false);
}
#[ink::test]
fn minting_tokens_works() {
let mut erc = Contract::new(Option::default());
set_sender(alice());
assert_eq!(erc.create(0, Option::default()), 1);
assert_eq!(erc.balance_of(alice(), 1), 0);
assert!(erc.mint(1, 123).is_ok());
assert_eq!(erc.balance_of(alice(), 1), 123);
}
#[ink::test]
fn minting_not_allowed_for_nonexistent_tokens() {
let mut erc = Contract::new(Option::default());
let res = erc.mint(1, 123);
assert_eq!(res.unwrap_err(), Error::UnexistentToken);
}
#[ink::test]
fn init_baseurl_works() {
let mut erc = Contract::new(Some(String::from("test")));
let baseUrl = erc.base_uri.unwrap();
assert_eq!(baseUrl, String::from("test"));
}
#[ink::test]
fn set_baseurl_works() {
let mut erc = Contract::new(Option::default());
erc.set_base_uri(Some(String::from("test2")));
let baseUrl = erc.base_uri.unwrap();
assert_eq!(baseUrl, String::from("test2"));
}
}
}
|
//! A pure rust replacement for the [miniz](https://github.com/richgel999/miniz)
//! DEFLATE/zlib encoder/decoder.
//! The plan for this crate is to be used as a back-end for the
//! [flate2](https://github.com/alexcrichton/flate2-rs) crate and eventually remove the
//! need to depend on a C library.
//!
//! # Usage
//! ## Simple compression/decompression:
//! ``` rust
//!
//! use miniz_oxide::inflate::decompress_to_vec;
//! use miniz_oxide::deflate::compress_to_vec;
//!
//! fn roundtrip(data: &[u8]) {
//! let compressed = compress_to_vec(data, 6);
//! let decompressed = decompress_to_vec(compressed.as_slice()).expect("Failed to decompress!");
//! # let _ = decompressed;
//! }
//!
//! # roundtrip(b"Test_data test data lalalal blabla");
//!
//! ```
extern crate adler32;
pub mod inflate;
pub mod deflate;
mod shared;
pub use shared::update_adler32 as mz_adler32_oxide;
pub use shared::MZ_ADLER32_INIT;
/// A list of flush types.
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum MZFlush {
None = 0,
Partial = 1,
Sync = 2,
Full = 3,
Finish = 4,
Block = 5,
}
impl MZFlush {
/// Create a Flush instance from an integer value.
///
/// Returns `MZError::Param` on invalid values.
pub fn new(flush: i32) -> Result<Self, MZError> {
match flush {
0 => Ok(MZFlush::None),
1 | 2 => Ok(MZFlush::Sync),
3 => Ok(MZFlush::Full),
4 => Ok(MZFlush::Finish),
_ => Err(MZError::Param),
}
}
}
/// A list of miniz successful status codes.
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum MZStatus {
Ok = 0,
StreamEnd = 1,
NeedDict = 2,
}
/// A list of miniz failed status codes.
#[repr(i32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum MZError {
ErrNo = -1,
Stream = -2,
Data = -3,
Mem = -4,
Buf = -5,
Version = -6,
Param = -10_000,
}
/// `Result` alias for all miniz status codes both successful and failed.
pub type MZResult = Result<MZStatus, MZError>;
|
//! File access and modification
use types::{char_t, int_t, timeval, utimbuf};
use syscalls::sys_utimes;
use rust::prelude::*;
/// Change file last access and modification times.
#[no_mangle]
pub unsafe extern fn utime(path: *const char_t, times: *const utimbuf) -> int_t {
if times.is_null() {
let mut tv = [
timeval {
tv_sec: (*times).actime,
tv_usec: 0,
},
timeval {
tv_sec: (*times).modtime,
tv_usec: 0,
}
];
forward!(sys_utimes, path, tv.as_mut_ptr())
} else {
forward!(sys_utimes, path, 0 as *mut timeval)
}
}
|
use crate::base::crypto::sha256::JSha256;
use crate::base::xcodec::util::{is_set, concat_args, seq_equal};
use crate::base::data::base_data::{BaseDataI};
use basex_rs::{BaseX, SKYWELL, Decode, Encode};
use hex;
pub trait XCodeI {
fn encode(bytes: &mut Vec<u8>, arg: Box<dyn BaseDataI>) -> String;
fn decode(string: &String, opts: Box<dyn BaseDataI>) -> Option<Vec<u8>>;
fn encode_raw(bytes: &mut Vec<u8>) -> String ;
fn decode_raw(string: String) -> Option<Vec<u8>>;
fn encode_checked(buffer: &mut Vec<u8>) -> String;
fn decode_checked(encoded: String) -> Option<Vec<u8>>;
fn encode_versioned(bytes: &mut Vec<u8>, arg: Box<dyn BaseDataI>) -> String;
fn decode_versioned(string: String, arg: Box<dyn BaseDataI>) -> Option<Vec<u8>>;
fn decode_multi_versioned(encoded: &String, arg: Box<dyn BaseDataI>) -> Option<Vec<u8>> ;
fn verify_checksum(bytes: &Vec<u8>) -> bool;
// fn find_prefix();
}
pub struct CodecFactory {}
impl CodecFactory {
pub fn new() -> Self {
// this.alphabet = alphabet;
// this.codec = baseCodec(alphabet);
// alphabet_len = alphabet.length;
CodecFactory {
}
}
}
impl XCodeI for CodecFactory {
fn encode(bytes: &mut Vec<u8>, arg: Box<dyn BaseDataI>) -> String {
let version = arg.get_version();
if is_set(&version) {
return CodecFactory::encode_versioned(bytes, arg);
} else {
if arg.get_checked().is_some() {
return CodecFactory::encode_checked(bytes);
} else {
return CodecFactory::encode_raw(bytes);
}
}
}
fn decode(string: &String, opts: Box<dyn BaseDataI>) -> Option<Vec<u8>> {
let versions = opts.get_versions();
if versions.is_some() {
return CodecFactory::decode_multi_versioned(string, opts);//opts.get_expected_length(), opts.get_version_type());
} else {
let version = opts.get_version();
if version.is_some() {
return CodecFactory::decode_versioned(string.to_string(), opts);
} else {
let checked = opts.get_checked();
if checked.is_some() {
return CodecFactory::decode_checked(string.to_string());
} else {
return CodecFactory::decode_raw(string.to_string());
}
}
}
}
fn encode_raw(bytes: &mut Vec<u8>) -> String {
BaseX::new(SKYWELL).encode(bytes.as_mut_slice())
}
fn decode_raw(string: String) -> Option<Vec<u8>> {
BaseX::new(SKYWELL).decode(string)
}
fn encode_checked(buffer: &mut Vec<u8>) -> String {
// var check = sha256(sha256(buffer)).slice(0, 4);
let check: Vec<u8> = JSha256::sha256(&buffer);
//6. take 0..4
let token = check.get(..4).unwrap().to_vec();
concat_args(buffer, &token);
CodecFactory::encode_raw(buffer)
}
fn decode_checked(encoded: String) -> Option<Vec<u8>> {
let bytes = CodecFactory::decode_raw(encoded).unwrap();
if bytes.len() < 5 {
panic!("invalid_input_size");
}
if CodecFactory::verify_checksum(&bytes) {
panic!("checksum_invalid");
}
// buf.slice(0, -4)
Some(bytes[0..bytes.len()-4].to_vec())
}
fn encode_versioned(bytes: &mut Vec<u8>, arg: Box<dyn BaseDataI>) -> String {
let expected_length = arg.get_expected_length().unwrap();
let version = arg.get_version().unwrap();
if expected_length == 0 && bytes.len() != expected_length {
panic!("unexpected_payload_length");
}
concat_args( bytes, &hex::decode(version).unwrap());
CodecFactory::encode_checked(bytes)
}
fn decode_versioned(string: String, arg: Box<dyn BaseDataI>) -> Option<Vec<u8>> {
CodecFactory::decode_multi_versioned(&string, arg)
}
//
fn decode_multi_versioned(_encoded: &String, _arg: Box<dyn BaseDataI>) -> Option<Vec<u8>> {
None
// let without_sum = CodecFactory::decodeChecked(encoded);
//
// let expected_length = arg.get_expected_length().unwrap();
//
// var ret = { version: null, bytes: null };
//
// if possible_versions.len() > 1 && expected_length == 0 {
// panic!("must pass expectedLengthgth > 1 possibleVersions");
// }
//
// let versionlen_guess = possible_versions[0].len() || 1; // Number.length
// let payload_length = arg.get_expected_length() || without_sum.len() - versionlen_guess;
// let version_bytes = without_sum.slice(0, -payload_length);
// let payload = without_sum.slice(-payload_length);
//
// var foundVersion = possibleVersions.some(function (version, i) {
// var asArray = Array.isArray(version) ? version : [version];
// if (seqEqual(versionBytes, asArray)) {
// ret.version = version;
// ret.bytes = payload;
// if (types) {
// ret.type = types[i];
// }
// return true;
// }
// });
//
// if ! found_version {
// panic!("version_invalid");
// }
//
// if expected_length == 0 && ret.bytes.length !== expected_length) {
// panic!("unexpected_payload_length");
// }
//
// return ret;
}
fn verify_checksum(bytes: &Vec<u8>) -> bool {
// let computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
// let checksum = bytes.slice(0..-4);
let computed = JSha256::sha256(&bytes[0..bytes.len()-4].to_vec()).get(..4).unwrap().to_vec();
let checksum = bytes[0..bytes.len()-4].to_vec();
seq_equal(&computed, &checksum)
}
// fn find_prefix(&self, desired_prefix: &str, payload_length: usize) {
// if (this.base !== 58) {
// panic!("Only works for base58");
// }
//
// let total_length = payload_length + 4;
// let chars = Math.log(Math.pow(256, total_length)) / Math.log(this.base);
//
// let requiredChars = Math.ceil(chars + 0.2);
// let padding = this.alphabet[Math.floor(this.alphabet.length / 2) - 1];
// let template = desiredPrefix + new Array(requiredChars + 1).join(padding);
// let bytes = this.decodeRaw(template);
// let version = bytes.slice(0, -totalLength);
//
// return version;
// }
}
|
use crate::logic::schema::ground_tiles_with_deleted;
#[derive(Insertable)]
#[table_name = "ground_tiles_with_deleted"]
pub struct GroundTileInput {
type_: String,
// deleted_at: Option<i64>
}
impl GroundTileInput {
pub fn new(types: String) -> GroundTileInput {
GroundTileInput {
type_: types,
// deleted_at: None
}
}
}
|
//! Handle packet encoding and peer ACK
use std::net::SocketAddr;
use std::mem;
use std::fmt::Debug;
use std::io::ErrorKind;
use std::collections::HashMap;
use futures::task::Task;
use futures::sync::mpsc::Sender;
use futures::stream::{futures_unordered, FuturesUnordered};
use tokio::prelude::*;
use tokio::{self, io, io::ReadHalf, io::WriteHalf};
use tokio::net::{TcpStream, tcp::ConnectFuture};
use bytes::{BytesMut, BufMut};
use bincode::{deserialize, serialize};
use ring::{aead, rand, rand::SecureRandom, aead::Nonce, aead::Aad};
use crate::{PeerId, PeerPresence, Error, Result};
use crate::transition::{Transition, TransitionKey};
/// The network key will be shared between all peers and contains
/// a 256bit key, encrypting and signing every transition send through the network
pub type NetworkKey = [u8; 32];
/// Peer-to-Peer message
///
/// The protocol is not very complex. After establishing a connection
/// every peer should send a Join message as a handshake. The peers
/// can then be requested with the GetPeers message. A push transmits
/// a new transition of the database state
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub enum Packet {
/// We ask to join in the network with a identity and our tips of the data graph
Join(PeerPresence, Vec<Transition>, Vec<TransitionKey>),
/// Ask for the current vector of peers
GetPeers(Option<Vec<PeerPresence>>),
/// Push a new packet into the network with reference to received transitions
Push(Transition),
Other(Vec<u8>),
Close
}
/// List of peers to be resolved
pub struct ResolvePeers {
awaiting: FuturesUnordered<Peer>,
ids: HashMap<PeerId, ()>
}
impl ResolvePeers {
pub fn new(peers: Vec<Peer>) -> ResolvePeers {
ResolvePeers {
awaiting: futures_unordered(peers),
ids: HashMap::new()
}
}
pub fn add_peer(&mut self, peer: Peer) {
self.awaiting.push(peer);
}
pub fn poll(&mut self) -> Poll<Option<(PeerCodecRead<TcpStream>, PeerCodecWrite<TcpStream>, PeerPresence, Vec<Transition>, Vec<TransitionKey>)>, io::Error> {
if let Some((read, write, presence, transitions, missing)) = try_ready!(self.awaiting.poll()) {
self.ids.insert(presence.id.clone(), ());
Ok(Async::Ready(Some((read, write, presence, transitions, missing))))
} else {
Ok(Async::Ready(None))
}
}
pub fn has_peer(&self, id: &PeerId) -> bool {
self.ids.contains_key(id)
}
}
/// Represent an emerging connection to a peer
///
/// There are two phases in the protocol, first the TCP connection should exist
/// then a Join message should tell something about the other peer. The resolved Future
/// gives the PeerCodec, the socket addr and the Join message.
pub enum Peer {
Connecting((ConnectFuture, NetworkKey, PeerPresence, Vec<Transition>, Vec<TransitionKey>)),
SendJoin((PeerCodecRead<TcpStream>, PeerCodecWrite<TcpStream>)),
WaitForJoin((PeerCodecRead<TcpStream>, PeerCodecWrite<TcpStream>)),
Ready
}
impl Peer {
/// Initialise a full peer connection with just the address
pub fn connect(addr: &SocketAddr, key: NetworkKey, myself: PeerPresence, tips: Vec<Transition>, missing: Vec<TransitionKey>) -> Peer {
let addr = addr.clone();
trace!("Connect to {:?} with {} tips", addr, tips.len());
Peer::Connecting((TcpStream::connect(&addr), key, myself, tips, missing))
}
/// Initialise a full peer connection with a connected TcpStream
pub fn send_join(socket: TcpStream, key: NetworkKey, myself: PeerPresence, tips: Vec<Transition>, missing: Vec<TransitionKey>) -> Peer {
let addr = socket.peer_addr().unwrap();
let (read, mut write) = new(socket, key);
trace!("Send JOIN to {:?} with {} tips", addr, tips.len());
write.buffer(Packet::Join(myself, tips, missing));
Peer::SendJoin((read, write))
}
}
/// Resolve to a fully connected peer
///
/// This future will ensure that 1. the TcpStream has been established and 2. the Join
/// message is received and valid. It is encoded as a state machine.
impl Future for Peer {
type Item=(PeerCodecRead<TcpStream>, PeerCodecWrite<TcpStream>, PeerPresence, Vec<Transition>, Vec<TransitionKey>);
type Error=io::Error;
fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
let mut poll_again = false;
let val = mem::replace(self, Peer::Ready);
let new_val = match val {
Peer::Connecting((mut socket_future, key, myself, tips, missing)) => {
// We are here in the connecting state, the TcpStream has no connection yet. As
// soon as the connection is established we will send the join message and then
// poll again.
match socket_future.poll()? {
Async::Ready(socket) => {poll_again = true; Peer::send_join(socket, key, myself, tips, missing)},
Async::NotReady => Peer::Connecting((socket_future, key, myself, tips, missing))
}
},
Peer::SendJoin((read, mut write)) => {
match write.poll_flush()? {
Async::Ready(_) => {poll_again = true; Peer::WaitForJoin((read, write))},
Async::NotReady => Peer::SendJoin((read, write))
}
},
Peer::WaitForJoin((mut read, write)) => {
// Poll the underlying socket through the PeerCodec for a Join message. If one
// arrives, we can resolve the future.
match read.poll()? {
Async::Ready(Some(Packet::Join(presence, new_transitions, missing))) => return Ok(Async::Ready((read, write, presence, new_transitions, missing))),
Async::Ready(None) => return {
error!("Got an invalid connection attempt!");
Err(io::Error::new(io::ErrorKind::ConnectionAborted, "test"))
},
_ => Peer::WaitForJoin((read, write))
}
},
_ => {
// The finished state is unreachable, because the future won't be called again
// after it is resolved.
unreachable!();
}
};
mem::replace(self, new_val);
if poll_again {
self.poll()
} else {
Ok(Async::NotReady)
}
}
}
/// Read half of the PeerCodec
///
/// The read half allows you to read arriving messages from the peer connection. It wraps a
/// TcpStream and converts the byte stream to a message stream by implementing the Stream trait.
pub struct PeerCodecRead<T: Debug + AsyncRead> {
read: ReadHalf<T>,
rd: BytesMut,
key: aead::LessSafeKey
}
/// Write half of the PeerCodec
///
/// The write half converts messages to a byte stream and send it to the peer. You can buffer
/// many messages inside the `wr` field and flush them all together with `poll_flush`.
pub struct PeerCodecWrite<T: Debug + AsyncWrite> {
write: WriteHalf<T>,
wr: BytesMut,
key: aead::LessSafeKey,
rng: rand::SystemRandom
}
/// The version field to prevent incompatible peer protocols
const VERSION: u8 = 3;
pub fn new<T: AsyncRead + AsyncWrite + Debug>(socket: T, key: NetworkKey) -> (PeerCodecRead<T>, PeerCodecWrite<T>) {
let (read, write) = socket.split();
// create opening/sealing keys (128bit network key)
let ukey = aead::UnboundKey::new(&aead::AES_256_GCM, &key).unwrap();
let read_key = aead::LessSafeKey::new(ukey);
let ukey = aead::UnboundKey::new(&aead::AES_256_GCM, &key).unwrap();
let write_key = aead::LessSafeKey::new(ukey);
//let write_key = aead::SealingKey::new(key, RandomNonce { rng: rand::SystemRandom::new() });
(
PeerCodecRead {
read: read,
rd: BytesMut::new(),
key: read_key
},
PeerCodecWrite {
write: write,
wr: BytesMut::new(),
key: write_key,
rng: rand::SystemRandom::new()
}
)
}
impl PeerCodecRead<TcpStream> {
/// Redirect the message stream to a channel
///
/// This will allow to connect many peers to a single GossipCodec. The channel unifies every
/// arriving messages by wrapping it with the PeerId. The GossipCodec can then process the
/// arriving messages according to the identification.
pub fn redirect_to(self, mut sender: Sender<(PeerId, Packet)>, id: PeerId, task: Task) {
let (task2, mut sender2, id2) = (task.clone(), sender.clone(), id.clone());
let mut sender3 = sender.clone();
let stream = self.map_err(|_| ())
.and_then(move |x| {
sender.start_send((id.clone(), x)).map_err(|err| {println!("Send error: {}", err); ()})
})
.and_then(move |_| {
task.notify();
sender3.poll_complete().map_err(|e| eprintln!("Err = {}", e))
})
.for_each(move |_| Ok(()))
.then(move |_| {
// ugh
sender2.try_send((id2.clone(), Packet::Close)).unwrap();
task2.notify();
let res: Result<()> = Ok(());
res
}).map_err(|_| ());
// create a new task which handles the copying
tokio::spawn(stream);
}
}
impl<T: Debug + AsyncRead> PeerCodecRead<T> {
/// Process a stream of bytes by decrypting, checking signature and unpacking the inner message
///
/// The header provides version checking and data encryption in the network. It provides for
/// this a `nonce` generated by AEAD as a unique encryption nonce and the `version` field to
/// distinguish between different protocol versions. Finally the length field
///
/// It has the following structure:
/// ----------------------------------------------
/// | 96bits | 6bits | 2bits | 8bits..32bits |
/// |---------|---------|--------|---------------|
/// | nonce | version | additi | length |
/// ---------------------------------------------|
///
/// Most of the time the header has a size of 16bit for small message with size < 256bits. The
/// `additional` field is then 0b00. For larger messages the length field can be enlarged by
/// the bytes in the `additional` field, up to 32bit. This results in a message size < 4G.
///
/// The function returns the version, the required length and then the received length.
pub fn version_length(&self) -> Option<(u8, u32, usize)> {
let rd = &self.rd;
// we need at least 112bits for a header
if rd.len() < 14 {
return None;
}
// read the version (6bit) and the length of the length field (2bit)
let (version, meta_length) = (rd[12] >> 2, rd[12] & 0b00000011);
// now continue to check whether we can read the length field
if rd.len() < (14 + meta_length) as usize {
return None;
}
// read the length as combination of the corresponding fields
let length = match meta_length {
0 => (rd[13] as u32),
1 => (rd[13] as u32) | (rd[14] as u32) << 8,
2 => (rd[13] as u32) | (rd[14] as u32) << 8 | (rd[15] as u32) << 16,
3 => (rd[13] as u32) | (rd[14] as u32) << 8 | (rd[15] as u32) << 16 | (rd[16] as u32) << 24,
_ => unreachable!()
};
Some((version, length, self.rd.len() - meta_length as usize - 14))
}
pub fn parse_packet(&mut self) -> Result<Packet> {
// read the header
let (version, required_length, buffer_length) = match self.version_length() {
Some((a,b,c)) => (a,b,c),
None => return Err(Error::NotEnoughBytes)
};
// check the version
if version != VERSION {
trace!("Parse packet with invalid version {} != {}", version, VERSION);
return Err(Error::WrongVersion);
}
//println!("Requied length: {}", required_length);
// continue till we have enough bytes
if required_length as usize > buffer_length {
return Err(Error::NotEnoughBytes);
}
// if we have reached the required byte number, read in the buffer
let meta_length = (self.rd[12] & 0b00000011) as usize;
let mut buf = self.rd.split_to(required_length as usize + 14 + meta_length);
// get once and create a copy
let nonce = Nonce::try_assume_unique_for_key(&buf[0..12]).unwrap();
//println!("Nonce {:?}", nonce);
//println!("Read buf {:?}", buf.len());
// decrypt and check signature
self.key.open_within(
nonce,
Aad::empty(),
&mut buf,
(14+meta_length)..
).map_err(|_| {
error!("Cryptographic failure, probably connection attempt with wrong network key!");
Error::Cryptography
})?;
// now try to deserialise it to a message, we have to skip the header bytes
deserialize::<Packet>(&buf).map_err(|_| Error::Deserialize)
}
/// Try to read in some data from the byte stream
fn fill_read_buf(&mut self) -> Poll<(), io::Error> {
loop {
self.rd.reserve(8192*2);
let read = self.read.read_buf(&mut self.rd);
let n = match read {
Ok(Async::Ready(n)) => {
trace!("Read {} bytes into buffer", n);
n
},
Ok(Async::NotReady) => return Ok(Async::NotReady),
Err(err) => {
if err.kind() == ErrorKind::WouldBlock {
return Ok(Async::NotReady);
} else {
return Err(err);
}
}
};
if n == 0 {
return Ok(Async::Ready(()));
}
}
}
}
impl<T: Debug + AsyncWrite> PeerCodecWrite<T> {
/// Buffer a message to the byte stream
///
/// First we serialise the message to a byte representation, and then
/// calculates the metadata values. After this we can push the block to the
/// data stream.
pub fn buffer(&mut self, message: Packet) {
//println!("Buffer: {:?}", message);
if let Ok(mut buf) = serialize(&message) {
trace!("Buffer {} bytes", buf.len());
// encrypt and sign our data with the network key
// TODO generate nonce
let mut nonce_buf = [0u8; 12];
self.rng.fill(&mut nonce_buf).unwrap();
let nonce = Nonce::assume_unique_for_key(nonce_buf);
// enlarge buffer for additional 128bits
//let tag_len = self.key.algorithm().tag_len() ;
//buf.append(&mut vec![0u8; tag_len]);
self.key.seal_in_place_append_tag(
nonce, // a unique and random key created for each message
Aad::empty(),
&mut buf, // buffer which will be overwritten with the encrypted and signed message
).unwrap();
let buf_len = buf.len();
// calculate the value of the `additional` field by couting the zeros of the buffer
// length
let length = (32 - (buf_len as u32).leading_zeros()) as u8 / 8;
// we can't transmit more than 4G at once, should never happen anyway
if length > 4 {
return;
}
// check if remaining space is sufficient
let rem = self.wr.capacity() - self.wr.len();
if rem < length as usize + 14 + buf_len {
let new_size = self.wr.len() + rem + length as usize + 14 + buf_len;
self.wr.reserve(new_size);
}
// write the nonce
self.wr.put(&nonce_buf[..]);
// put the `version` and `additional` field to the write buffer
self.wr.put_u8(VERSION << 2 | length);
// write the buffer length
let mut buf_length = buf_len;
for _ in 0..length+1 {
self.wr.put_u8((buf_length & 0xFF) as u8);
buf_length = buf_length >> 8;
}
// put the message itself to the buffer
self.wr.put(&buf[0..buf_len]);
}
}
/// Flush the whole write buffer to the underlying socket
pub fn poll_flush(&mut self) -> Poll<(), io::Error> {
while !self.wr.is_empty() {
let n = try_ready!(self.write.poll_write(&self.wr));
trace!("Flushed {} left {}", n, self.wr.len());
assert!(n > 0);
self.wr.split_to(n);
}
self.write.poll_flush()
}
pub fn shutdown(mut self) -> Poll<(), io::Error> {
self.write.shutdown()
}
pub fn is_empty(&self) -> bool {
self.wr.len() == 0
}
}
/// Packet stream consuming the underlying byte stream. bytes_stream -> message_stream
///
/// The PeerCodec consumes a byte stream and tries to construct messages from it. The messages
/// can then be used by the GossipCodec to communicate with a peer.
impl<T: Debug + AsyncRead> Stream for PeerCodecRead<T> {
type Item = Packet;
type Error = io::Error;
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
// read new data that might have been received off the socket
// track if the socket is closed here
let res = self.fill_read_buf()
.map_err(|x| {println!("{:?}", x); x})?;
let is_closed = res.is_ready();
if is_closed {
// the socket seems to have closed after the last call, signal that
// the stream is finished, because we can't receive any new data
return Ok(Async::Ready(None));
}
let res = self.parse_packet();
match res {
Ok(msg) => Ok(Async::Ready(Some(msg))),
// peer has a wrong version, close connection
Err(Error::WrongVersion) => Ok(Async::Ready(None)),
// peer sent probably a wrong key, close connection
Err(Error::Cryptography) => Ok(Async::Ready(None)),
// in all other cases we await more bytes
Err(Error::Deserialize) => Ok(Async::NotReady),
Err(Error::NotEnoughBytes) => Ok(Async::NotReady),
_ => Ok(Async::NotReady)
}
}
}
#[cfg(test)]
mod tests {
use super::{new, Packet, Transition, PeerId};
use std::io::Cursor;
use bytes::BufMut;
use ring::rand::{SecureRandom, SystemRandom};
use test::Bencher;
#[test]
fn read_write() {
let mut buf = Cursor::new(Vec::new());
let rng = SystemRandom::new();
let mut tmp = vec![0u8; 65536];
rng.fill(&mut tmp).unwrap();
let packet = Packet::Push(Transition::new(Vec::new(), Vec::new(), tmp));
let mut key = [0u8; 32];
rng.fill(&mut key).unwrap();
let (mut read, mut write) = new(&mut buf, key);
write.buffer(packet.clone());
read.rd.reserve(write.wr.len());
read.rd.put_slice(&write.wr.as_ref());
assert_eq!(read.parse_packet().unwrap(), packet);
}
// size of a random payload
const BUF_SIZE: usize = 8192;
#[bench]
fn bench_encrypt(b: &mut Bencher) {
let mut buf = Cursor::new(Vec::new());
let rng = SystemRandom::new();
let mut tmp = vec![0u8; BUF_SIZE];
rng.fill(&mut tmp).unwrap();
let packet = Packet::Push(Transition::new(Vec::new(), Vec::new(), tmp));
let mut key = [0u8; 32];
rng.fill(&mut key).unwrap();
let (_, mut write) = new(&mut buf, key);
b.iter(|| write.buffer(packet.clone()));
}
#[bench]
fn bench_decrypt(b: &mut Bencher) {
let mut buf = Cursor::new(Vec::new());
let rng = SystemRandom::new();
let mut tmp = vec![0u8; BUF_SIZE];
rng.fill(&mut tmp).unwrap();
let packet = Packet::Push(Transition::new(Vec::new(), Vec::new(), tmp));
let mut key = [0u8; 32];
rng.fill(&mut key).unwrap();
let (mut read, mut write) = new(&mut buf, key);
write.buffer(packet.clone());
read.rd.reserve(write.wr.len());
b.iter(|| {
read.rd.reserve(write.wr.len());
read.rd.put_slice(&write.wr.as_ref());
read.parse_packet().unwrap();
});
}
}
|
// Copyright (c) 2021 Quark Container Authors / 2018 The gVisor Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
use alloc::string::String;
use alloc::vec::Vec;
use alloc::sync::Arc;
use spin::Mutex;
use core::any::Any;
use alloc::collections::btree_map::BTreeMap;
use socket::unix::transport::unix::BoundEndpoint;
use super::super::super::qlib::common::*;
use super::super::super::qlib::linux_def::*;
use super::super::super::qlib::auth::*;
use super::super::super::qlib::device::*;
use super::super::super::kernel::time::*;
use super::super::super::task::*;
use super::super::attr::*;
use super::super::mount::*;
use super::super::flags::*;
use super::super::file::*;
use super::super::inode::*;
use super::super::dirent::*;
use super::super::host::hostinodeop::*;
use super::super::ramfs::dir::*;
use super::tmpfs_symlink::*;
use super::tmpfs_socket::*;
use super::tmpfs_file::*;
use super::tmpfs_fifo::*;
pub const TMPFS_FSINFO : FsInfo = FsInfo {
Type: FSMagic::TMPFS_MAGIC,
TotalBlocks: 0,
FreeBlocks: 0,
TotalFiles: 0,
FreeFiles: 0,
};
pub fn TmpfsRename(task: &Task, oldParent: &Inode, oldname: &str, newParent: &Inode, newname: &str, _replacement: bool) -> Result<()> {
let oldInode = oldParent.lock().InodeOp.clone();
let op = match oldInode.as_any().downcast_ref::<TmpfsDir>() {
None => return Err(Error::SysError(SysErr::EXDEV)),
Some(op) => op.clone(),
};
let newInode = newParent.lock().InodeOp.clone();
let np = match newInode.as_any().downcast_ref::<TmpfsDir>() {
None => return Err(Error::SysError(SysErr::EXDEV)),
Some(op) => op.clone(),
};
Rename(task, Arc::new(op.0.clone()), oldname, Arc::new(np.0.clone()), newname, _replacement)
}
pub fn NewTmpfsDir(task: &Task,
contents: BTreeMap<String, Inode>,
owner: &FileOwner,
perms: &FilePermissions,
msrc: Arc<Mutex<MountSource>>) -> Inode {
let d = Dir::New(task, contents, owner, perms);
let d = TmpfsDir(d);
let createOps = d.NewCreateOps();
d.0.write().CreateOps = createOps;
let deviceId = TMPFS_DEVICE.lock().DeviceID();
let inodeId = TMPFS_DEVICE.lock().NextIno();
let attr = StableAttr {
Type: InodeType::Directory,
DeviceId: deviceId,
InodeId: inodeId,
BlockSize: MemoryDef::PAGE_SIZE as i64,
DeviceFileMajor: 0,
DeviceFileMinor: 0,
};
return Inode::New(&Arc::new(d), &msrc, &attr);
}
pub struct TmpfsDir(pub Dir);
fn NewDirFn(task: &Task, dir: &Inode, perms: &FilePermissions) -> Result<Inode> {
let msrc = dir.lock().MountSource.clone();
return Ok(NewTmpfsDir(task, BTreeMap::new(), &task.FileOwner(), perms, msrc))
}
fn NewSymlinkFn(task: &Task, dir: &Inode, target: &str) -> Result<Inode> {
let msrc = dir.lock().MountSource.clone();
return Ok(NewTmpfsSymlink(task, target, &task.FileOwner(), &msrc))
}
fn NewSocketFn(task: &Task, dir: &Inode, socket: &BoundEndpoint, perms: &FilePermissions) -> Result<Inode> {
let msrc = dir.lock().MountSource.clone();
return Ok(NewTmpfsSocket(task, socket, &task.FileOwner(), perms, &msrc))
}
fn NewFileFn(task: &Task, dir: &Inode, perms: &FilePermissions) -> Result<Inode> {
let msrc = dir.lock().MountSource.clone();
let uattr = UnstableAttr {
Owner: task.FileOwner(),
Perms: *perms,
..Default::default()
};
let uattr = WithCurrentTime(task, &uattr);
return NewTmpfsFileInode(task, uattr, &msrc)
}
fn NewFifoFn(task: &Task, dir: &Inode, perms: &FilePermissions) -> Result<Inode> {
let msrc = dir.lock().MountSource.clone();
return NewTmpfsFifoInode(task, perms, &msrc)
}
impl TmpfsDir {
pub fn NewCreateOps(&self) -> CreateOps {
return CreateOps {
NewDir: Some(NewDirFn),
NewFile: Some(NewFileFn),
NewSymlink: Some(NewSymlinkFn),
NewBoundEndpoint: Some(NewSocketFn),
NewFifo: Some(NewFifoFn),
..Default::default()
}
}
}
impl InodeOperations for TmpfsDir {
fn as_any(&self) -> &Any {
return self
}
fn IopsType(&self) -> IopsType {
return IopsType::TmpfsDir;
}
fn InodeType(&self) -> InodeType {
return self.0.InodeType();
}
fn InodeFileType(&self) -> InodeFileType{
return InodeFileType::TmpfsDir;
}
fn WouldBlock(&self) -> bool {
return self.0.WouldBlock();
}
fn Lookup(&self, task: &Task, dir: &Inode, name: &str) -> Result<Dirent> {
return self.0.Lookup(task, dir, name)
}
fn Create(&self, task: &Task, dir: &mut Inode, name: &str, flags: &FileFlags, perm: &FilePermissions) -> Result<File> {
return self.0.Create(task, dir, name, flags, perm)
}
fn CreateDirectory(&self, task: &Task, dir: &mut Inode, name: &str, perm: &FilePermissions) -> Result<()> {
return self.0.CreateDirectory(task, dir, name, perm)
}
fn CreateLink(&self, task: &Task, dir: &mut Inode, oldname: &str, newname: &str) -> Result<()> {
return self.0.CreateLink(task, dir, oldname, newname)
}
fn CreateHardLink(&self, task: &Task, dir: &mut Inode, target: &Inode, name: &str) -> Result<()> {
return self.0.CreateHardLink(task, dir, target, name)
}
fn CreateFifo(&self, task: &Task, dir: &mut Inode, name: &str, perm: &FilePermissions) -> Result<()> {
return self.0.CreateFifo(task, dir, name, perm)
}
//fn RemoveDirent(&mut self, dir: &mut InodeStruStru, remove: &Arc<Mutex<Dirent>>) -> Result<()> ;
fn Remove(&self, task: &Task, dir: &mut Inode, name: &str) -> Result<()> {
//todo: fix remove fifo
return self.0.Remove(task, dir, name)
}
fn RemoveDirectory(&self, task: &Task, dir: &mut Inode, name: &str) -> Result<()>{
return self.0.RemoveDirectory(task, dir, name)
}
fn Rename(&self, task: &Task, _dir: &mut Inode, oldParent: &Inode, oldname: &str, newParent: &Inode, newname: &str, replacement: bool) -> Result<()> {
return TmpfsRename(task, oldParent, oldname, newParent, newname, replacement)
}
fn Bind(&self, task: &Task, dir: &Inode, name: &str, data: &BoundEndpoint, perms: &FilePermissions) -> Result<Dirent> {
return self.0.Bind(task, dir, name, data, perms)
}
fn BoundEndpoint(&self, task: &Task, inode: &Inode, path: &str) -> Option<BoundEndpoint> {
return self.0.BoundEndpoint(task, inode, path)
}
fn GetFile(&self, task: &Task, dir: &Inode, dirent: &Dirent, flags: FileFlags) -> Result<File> {
return self.0.GetFile(task, dir, dirent, flags)
}
fn UnstableAttr(&self, task: &Task, dir: &Inode) -> Result<UnstableAttr> {
return self.0.UnstableAttr(task, dir)
}
fn Getxattr(&self, dir: &Inode, name: &str) -> Result<String> {
return self.0.Getxattr(dir, name)
}
fn Setxattr(&self, dir: &mut Inode, name: &str, value: &str) -> Result<()> {
return self.0.Setxattr(dir, name, value)
}
fn Listxattr(&self, dir: &Inode) -> Result<Vec<String>> {
return self.0.Listxattr(dir)
}
fn Check(&self, task: &Task, inode: &Inode, reqPerms: &PermMask) -> Result<bool> {
return self.0.Check(task, inode, reqPerms)
}
fn SetPermissions(&self, task: &Task, dir: &mut Inode, f: FilePermissions) -> bool {
return self.0.SetPermissions(task, dir, f)
}
fn SetOwner(&self, task: &Task, dir: &mut Inode, owner: &FileOwner) -> Result<()> {
return self.0.SetOwner(task, dir, owner)
}
fn SetTimestamps(&self, task: &Task, dir: &mut Inode, ts: &InterTimeSpec) -> Result<()> {
return self.0.SetTimestamps(task, dir, ts)
}
fn Truncate(&self, task: &Task, dir: &mut Inode, size: i64) -> Result<()> {
return self.0.Truncate(task, dir, size)
}
fn Allocate(&self, task: &Task, dir: &mut Inode, offset: i64, length: i64) -> Result<()> {
return self.0.Allocate(task, dir, offset, length)
}
fn ReadLink(&self, task: &Task,dir: &Inode) -> Result<String> {
return self.0.ReadLink(task, dir)
}
fn GetLink(&self, task: &Task, dir: &Inode) -> Result<Dirent> {
return self.0.GetLink(task, dir)
}
fn AddLink(&self, task: &Task) {
return self.0.AddLink(task)
}
fn DropLink(&self, task: &Task) {
return self.0.DropLink(task)
}
fn IsVirtual(&self) -> bool {
return self.0.IsVirtual()
}
fn Sync(&self) -> Result<()> {
return self.0.Sync()
}
fn StatFS(&self, _task: &Task) -> Result<FsInfo> {
return Ok(TMPFS_FSINFO)
}
fn Mappable(&self) -> Result<HostInodeOp> {
return self.0.Mappable()
}
} |
pub struct Solution;
#[derive(PartialEq, Eq, Clone, Debug)]
pub struct ListNode {
pub val: i32,
pub next: List,
}
type List = Option<Box<ListNode>>;
impl Solution {
pub fn reverse_k_group(head: List, k: i32) -> List {
let mut head = head;
let mut current = &mut head;
while has_k_next(current, k) {
let mut x = current.take();
let mut y = None;
for _ in 0..k {
let mut tmp = x;
x = tmp.as_mut().unwrap().next.take();
tmp.as_mut().unwrap().next = y;
y = tmp;
}
*current = y;
for _ in 0..k {
current = &mut current.as_mut().unwrap().next;
}
*current = x;
}
head
}
}
fn has_k_next(head: &List, k: i32) -> bool {
let mut current = head;
for _ in 0..k {
if current.is_none() {
return false;
}
current = ¤t.as_ref().unwrap().next;
}
true
}
#[test]
fn test0025() {
fn cons(val: i32, next: List) -> List {
Some(Box::new(ListNode { val, next }))
}
assert_eq!(
Solution::reverse_k_group(cons(1, cons(2, cons(3, cons(4, cons(5, None))))), 2),
cons(2, cons(1, cons(4, cons(3, cons(5, None)))))
);
assert_eq!(
Solution::reverse_k_group(cons(1, cons(2, cons(3, cons(4, cons(5, None))))), 3),
cons(3, cons(2, cons(1, cons(4, cons(5, None)))))
);
}
|
use crate::prelude::*;
use presentation::wsi::windowsystemintegration::WindowSystemIntegration;
use std::path::Path;
pub struct WindowConfig<'a> {
wsi: &'a WindowSystemIntegration,
}
impl<'a> WindowConfig<'a> {
pub(crate) fn new(wsi: &'a WindowSystemIntegration) -> Self {
WindowConfig { wsi }
}
pub fn set_cursor<T: AsRef<Path>>(&self, bmp: T) -> VerboseResult<()> {
self.wsi.set_cursor(bmp)
}
pub fn toggle_fullscreen(&self) -> VerboseResult<()> {
self.wsi.set_fullscreen(!self.wsi.is_fullscreen()?)
}
pub fn set_icon<T: AsRef<Path>>(&self, bmp: T) -> VerboseResult<()> {
self.wsi.set_icon(bmp)
}
pub fn set_opacity(&self, opacity: f32) -> VerboseResult<()> {
self.wsi.set_opacity(opacity)
}
pub fn show_simple_info_box(&self, title: &str, message: &str) -> VerboseResult<()> {
self.wsi.show_simple_info_box(title, message)
}
pub fn show_simple_warning_box(&self, title: &str, message: &str) -> VerboseResult<()> {
self.wsi.show_simple_warning_box(title, message)
}
pub fn show_simple_error_box(&self, title: &str, message: &str) -> VerboseResult<()> {
self.wsi.show_simple_error_box(title, message)
}
pub fn displays(&self) -> &[Display] {
self.wsi.displays()
}
}
|
pub fn maximum69_number(num: i32) -> i32 {
num.to_string().replacen("6", "9", 1).parse().unwrap()
}
#[cfg(test)]
mod maximum69_number_tests {
use super::*;
#[test]
fn maximum69_number_test_one() {
// arrange
let test = 9669;
// act
let result = maximum69_number(test);
// assert
assert_eq!(result, 9969);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.